@harpy-js/core 0.4.7

package/dist/core/hydration-manifest.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHydrationManifest = getHydrationManifest;
+exports.getChunkFileName = getChunkFileName;
+exports.getChunkPath = getChunkPath;
+exports.invalidateManifestCache = invalidateManifestCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let cachedManifest = null;
+function getHydrationManifest() {
+    if (cachedManifest) {
+        return cachedManifest;
+    }
+    const manifestPaths = [
+        path.join(process.cwd(), "dist", "hydration-manifest.json"),
+        path.join(process.cwd(), "src", "hydration-manifest.json"),
+    ];
+    let manifestPath = null;
+    for (const p of manifestPaths) {
+        if (fs.existsSync(p)) {
+            manifestPath = p;
+            break;
+        }
+    }
+    if (!manifestPath) {
+        console.warn("[Hydration] Manifest file not found at any of:", manifestPaths, "- ensure build:hydration has been run");
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        cachedManifest = JSON.parse(content);
+        return cachedManifest;
+    }
+    catch (error) {
+        console.error("[Hydration] Failed to load hydration manifest:", error);
+        cachedManifest = {};
+        return cachedManifest;
+    }
+}
+function getChunkFileName(componentName) {
+    const manifest = getHydrationManifest();
+    return manifest[componentName] || null;
+}
+function getChunkPath(componentName) {
+    const fileName = getChunkFileName(componentName);
+    return fileName ? `/chunks/${fileName}` : null;
+}
+function invalidateManifestCache() {
+    cachedManifest = null;
+}

package/dist/core/hydration.d.ts

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "async_hooks";
+export interface ClientComponentInstance {
+    componentPath: string;
+    componentName: string;
+    instanceId: string;
+    props: Record<string, any>;
+}
+export interface HydrationContext {
+    clientComponents: Map<string, ClientComponentInstance>;
+}
+export declare const hydrationContext: AsyncLocalStorage<HydrationContext>;
+export declare function generateInstanceId(componentPath: string): string;
+export declare function initializeHydrationContext(): HydrationContext;
+export declare function registerClientComponent(instance: ClientComponentInstance): void;
+export declare function getClientComponents(): ClientComponentInstance[];
+export declare function clearHydrationContext(): void;

package/dist/core/hydration.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrationContext = void 0;
+exports.generateInstanceId = generateInstanceId;
+exports.initializeHydrationContext = initializeHydrationContext;
+exports.registerClientComponent = registerClientComponent;
+exports.getClientComponents = getClientComponents;
+exports.clearHydrationContext = clearHydrationContext;
+const async_hooks_1 = require("async_hooks");
+const crypto = __importStar(require("crypto"));
+exports.hydrationContext = new async_hooks_1.AsyncLocalStorage();
+function generateInstanceId(componentPath) {
+    return `${crypto.randomBytes(4).toString("hex")}-${Date.now()}`;
+}
+function initializeHydrationContext() {
+    const context = {
+        clientComponents: new Map(),
+    };
+    return context;
+}
+function registerClientComponent(instance) {
+    const context = exports.hydrationContext.getStore();
+    if (context) {
+        context.clientComponents.set(instance.instanceId, instance);
+    }
+}
+function getClientComponents() {
+    const context = exports.hydrationContext.getStore();
+    if (!context) {
+        return [];
+    }
+    return Array.from(context.clientComponents.values());
+}
+function clearHydrationContext() {
+    const context = exports.hydrationContext.getStore();
+    if (context) {
+        context.clientComponents.clear();
+    }
+}

package/dist/core/jsx.engine.d.ts

@@ -0,0 +1,9 @@
+import { NestFastifyApplication } from "@nestjs/platform-fastify";
+import * as React from "react";
+import { MetaOptions } from "../decorators/jsx.decorator";
+export interface JsxLayoutProps {
+    children: React.ReactNode;
+    meta?: MetaOptions;
+}
+export type JsxLayout = (props: JsxLayoutProps) => React.ReactElement;
+export declare function withJsxEngine(app: NestFastifyApplication, defaultLayout: JsxLayout): void;

package/dist/core/jsx.engine.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withJsxEngine = withJsxEngine;
+const React = __importStar(require("react"));
+const server_1 = require("react-dom/server");
+const hydration_1 = require("./hydration");
+const hydration_manifest_1 = require("./hydration-manifest");
+const live_reload_controller_1 = require("./live-reload.controller");
+const static_assets_controller_1 = require("./static-assets.controller");
+const chunkPathCache = new Map();
+function initializeChunkCache() {
+    const manifest = (0, hydration_manifest_1.getHydrationManifest)();
+    Object.keys(manifest).forEach((componentName) => {
+        const path = (0, hydration_manifest_1.getChunkPath)(componentName);
+        if (path) {
+            chunkPathCache.set(componentName, path);
+        }
+    });
+    console.log(`[JSX Engine] Preloaded ${chunkPathCache.size} component chunk mappings`);
+}
+function withJsxEngine(app, defaultLayout) {
+    const isDev = process.env.NODE_ENV !== "production";
+    initializeChunkCache();
+    if (isDev) {
+        const httpAdapter = app.getHttpAdapter();
+        const liveReloadController = new live_reload_controller_1.LiveReloadController();
+        const staticAssetsController = new static_assets_controller_1.StaticAssetsController();
+        httpAdapter.get("/__harpy/live-reload", (req, reply) => {
+            liveReloadController.liveReload(reply);
+        });
+        httpAdapter.post("/__harpy/live-reload/trigger", (req, reply) => {
+            liveReloadController.notifyReload();
+            reply.send({ status: "ok" });
+        });
+        httpAdapter.get("/__harpy/live-reload.js", (req, reply) => {
+            staticAssetsController.liveReloadScript(reply);
+        });
+    }
+    app.getHttpAdapter().render = async function (reply, view, options) {
+        const res = reply.raw;
+        if (reply.statusCode >= 300) {
+            res.end();
+            return;
+        }
+        const [component, controllerOpts] = view;
+        const layout = controllerOpts.layout ?? defaultLayout;
+        const props = {
+            ...options,
+        };
+        let meta = undefined;
+        if (typeof controllerOpts.meta === "function") {
+            try {
+                meta = await controllerOpts.meta(reply.request, props);
+            }
+            catch (e) {
+                console.error("Error resolving dynamic meta:", e);
+            }
+        }
+        else {
+            meta = controllerOpts.meta;
+        }
+        const layoutProps = {
+            ...props,
+            meta,
+        };
+        let html;
+        if (layout) {
+            layoutProps.children = React.createElement(component, props);
+            html = React.createElement(layout, layoutProps);
+        }
+        else {
+            html = React.createElement(component, props);
+        }
+        const hydrationCtx = (0, hydration_1.initializeHydrationContext)();
+        global.__COMPONENT_REGISTRY__ = (data) => {
+            hydrationCtx.clientComponents.set(data.instanceId, data);
+        };
+        const startTime = Date.now();
+        let htmlString = "";
+        hydration_1.hydrationContext.run(hydrationCtx, () => {
+            try {
+                htmlString = (0, server_1.renderToString)(html);
+            }
+            catch (e) {
+                console.error("[JSX Engine] Render error:", e.message?.split("\n")[0]);
+                throw e;
+            }
+        });
+        const registeredComponents = Array.from(hydrationCtx.clientComponents.values());
+        const uniqueComponentNames = new Set(registeredComponents.map((c) => c.componentName));
+        const hydrationScripts = Array.from(uniqueComponentNames)
+            .map((componentName) => {
+            const path = chunkPathCache.get(componentName);
+            if (!path) {
+                const livePath = (0, hydration_manifest_1.getChunkPath)(componentName);
+                if (livePath) {
+                    chunkPathCache.set(componentName, livePath);
+                    return { componentName, path: livePath };
+                }
+                return null;
+            }
+            return { componentName, path };
+        })
+            .filter((script) => script !== null);
+        const renderTime = Date.now() - startTime;
+        if (isDev) {
+            console.log(`[JSX Engine] Rendered in ${renderTime}ms with ${hydrationScripts.length} scripts for:`, Array.from(uniqueComponentNames).join(", "));
+        }
+        let hydrationScriptsHtml = "";
+        if (hydrationScripts.length > 0) {
+            hydrationScriptsHtml = '<script src="/chunks/vendor.js"></script>';
+            hydrationScripts.forEach((script) => {
+                hydrationScriptsHtml += `<script src="${script.path}"></script>`;
+            });
+        }
+        if (isDev) {
+            const liveReloadScript = '<script src="/__harpy/live-reload.js"></script>';
+            const scriptsToInject = `${hydrationScriptsHtml}${liveReloadScript}`;
+            htmlString = htmlString.replace("</body>", `${scriptsToInject}</body>`);
+        }
+        else if (hydrationScriptsHtml) {
+            htmlString = htmlString.replace("</body>", `${hydrationScriptsHtml}</body>`);
+        }
+        res.setHeader("content-type", "text/html");
+        reply.status(reply.statusCode || 200);
+        res.end(htmlString);
+    };
+}

package/dist/core/live-reload-client.js

@@ -0,0 +1,32 @@
+/**
+ * Harpy Live Reload Client
+ * Connects to the dev server via SSE and reloads the page when changes are detected
+ */
+(function () {
+  if (typeof window === "undefined") return;
+
+  const eventSource = new EventSource("/__harpy/live-reload");
+
+  eventSource.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      if (data.type === "reload") {
+        console.log("[Harpy] Reloading page...");
+        window.location.reload();
+      } else if (data.type === "connected") {
+        console.log("[Harpy] Live reload connected");
+      }
+    } catch (err) {
+      console.error("[Harpy] Failed to parse message:", err);
+    }
+  };
+
+  eventSource.onerror = () => {
+    console.log("[Harpy] Live reload disconnected, retrying...");
+    eventSource.close();
+    // Retry connection after 1 second
+    setTimeout(() => {
+      window.location.reload();
+    }, 1000);
+  };
+})();

package/dist/core/live-reload.controller.d.ts

@@ -0,0 +1,10 @@
+import { FastifyReply } from "fastify";
+export declare class LiveReloadController {
+    private clients;
+    private lastReloadTime;
+    liveReload(reply: FastifyReply): void;
+    triggerReload(): {
+        success: boolean;
+    };
+    notifyReload(): void;
+}

package/dist/core/live-reload.controller.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveReloadController = void 0;
+class LiveReloadController {
+    clients = [];
+    lastReloadTime = Date.now();
+    liveReload(reply) {
+        reply.raw.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        this.clients.push(reply);
+        reply.raw.write(`data: ${JSON.stringify({ type: "connected" })}\n\n`);
+        reply.raw.on("close", () => {
+            const index = this.clients.indexOf(reply);
+            if (index !== -1) {
+                this.clients.splice(index, 1);
+            }
+        });
+    }
+    triggerReload() {
+        this.notifyReload();
+        return { success: true };
+    }
+    notifyReload() {
+        this.lastReloadTime = Date.now();
+        const message = `data: ${JSON.stringify({ type: "reload", timestamp: this.lastReloadTime })}\n\n`;
+        this.clients.forEach((client) => {
+            try {
+                client.raw.write(message);
+            }
+            catch (err) {
+            }
+        });
+    }
+}
+exports.LiveReloadController = LiveReloadController;

package/dist/core/navigation.service.d.ts

@@ -0,0 +1,18 @@
+import type { NavItem, NavSection, NavigationRegistry } from "./types/nav.types";
+export declare class NavigationService implements NavigationRegistry {
+    private sections;
+    private topLevelItems;
+    private cachedSections;
+    private dirty;
+    private hrefIndex;
+    constructor();
+    registerSection(section: NavSection): void;
+    addItemToSection(sectionId: string, item: NavItem): void;
+    registerItem(item: NavItem): void;
+    getAllSections(): NavSection[];
+    private ensureCache;
+    getActiveItemId(currentPath?: string): string | undefined;
+    getSectionsForRoute(currentPath?: string): NavSection[];
+    getSection(sectionId: string): NavSection | undefined;
+    moveSectionToFront(sectionId: string): void;
+}

package/dist/core/navigation.service.js

@@ -0,0 +1,206 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationService = void 0;
+const common_1 = require("@nestjs/common");
+let NavigationService = class NavigationService {
+    sections = new Map();
+    topLevelItems = [];
+    cachedSections = null;
+    dirty = true;
+    hrefIndex = new Map();
+    constructor() { }
+    registerSection(section) {
+        this.sections.set(section.id, section);
+    }
+    addItemToSection(sectionId, item) {
+        let section = this.sections.get(sectionId);
+        if (!section) {
+            const humanize = (id) => id.replace(/[-_/]+/g, " ").replace(/(^|\s)\S/g, (s) => s.toUpperCase());
+            section = {
+                id: sectionId,
+                title: humanize(sectionId),
+                items: [],
+            };
+            this.registerSection(section);
+        }
+        section.items.push(item);
+    }
+    registerItem(item) {
+        this.topLevelItems.push(item);
+        this.dirty = true;
+    }
+    getAllSections() {
+        if (!this.dirty && this.cachedSections) {
+            return this.cachedSections.map((s) => ({ ...s, items: s.items.slice() }));
+        }
+        const sectionsList = Array.from(this.sections.values());
+        if (this.topLevelItems.length > 0) {
+            sectionsList.unshift({
+                id: "__top__",
+                title: "",
+                items: this.topLevelItems.slice(),
+            });
+        }
+        const arr = sectionsList.map((s, idx) => ({
+            section: s,
+            idx,
+            order: s.id === "__top__"
+                ? Number.NEGATIVE_INFINITY
+                : typeof s.order === "number"
+                    ? s.order
+                    : Number.POSITIVE_INFINITY,
+        }));
+        arr.sort((a, b) => {
+            if (a.order === b.order)
+                return a.idx - b.idx;
+            return a.order - b.order;
+        });
+        const built = arr.map((x) => {
+            const s = x.section;
+            const itemsWithMeta = s.items.map((it, i) => ({
+                item: it,
+                idx: i,
+                order: typeof it.order === "number" ? it.order : Number.POSITIVE_INFINITY,
+            }));
+            itemsWithMeta.sort((u, v) => {
+                if (u.order === v.order)
+                    return u.idx - v.idx;
+                return u.order - v.order;
+            });
+            return {
+                id: s.id,
+                title: s.title,
+                order: s.order,
+                items: itemsWithMeta.map((m) => m.item),
+            };
+        });
+        this.hrefIndex.clear();
+        const normalize = (p) => {
+            if (!p)
+                return "";
+            const withoutQuery = p.split(/[?#]/)[0];
+            if (withoutQuery.length > 1 && withoutQuery.endsWith("/"))
+                return withoutQuery.slice(0, -1);
+            return withoutQuery;
+        };
+        for (const s of built) {
+            for (const it of s.items) {
+                if (!it.href)
+                    continue;
+                const key = normalize(it.href);
+                if (!this.hrefIndex.has(key))
+                    this.hrefIndex.set(key, []);
+                this.hrefIndex
+                    .get(key)
+                    .push({
+                    sectionId: s.id === "__top__" ? undefined : s.id,
+                    itemId: it.id,
+                });
+            }
+        }
+        this.cachedSections = built;
+        this.dirty = false;
+        return built.map((s) => ({ ...s, items: s.items.slice() }));
+    }
+    ensureCache() {
+        if (this.dirty)
+            this.getAllSections();
+    }
+    getActiveItemId(currentPath) {
+        if (!currentPath)
+            return undefined;
+        this.ensureCache();
+        const normalize = (p) => {
+            if (!p)
+                return "";
+            const withoutQuery = p.split(/[?#]/)[0];
+            if (withoutQuery.length > 1 && withoutQuery.endsWith("/"))
+                return withoutQuery.slice(0, -1);
+            return withoutQuery;
+        };
+        let cur = normalize(currentPath);
+        while (cur !== "") {
+            const entry = this.hrefIndex.get(cur);
+            if (entry && entry.length > 0)
+                return entry[0].itemId;
+            const lastSlash = cur.lastIndexOf("/");
+            if (lastSlash === -1)
+                break;
+            if (lastSlash === 0) {
+                cur = "/";
+            }
+            else {
+                cur = cur.slice(0, lastSlash);
+            }
+            if (cur === "/") {
+                const entryRoot = this.hrefIndex.get("/");
+                if (entryRoot && entryRoot.length > 0)
+                    return entryRoot[0].itemId;
+                break;
+            }
+        }
+        return undefined;
+    }
+    getSectionsForRoute(currentPath) {
+        const normalize = (p) => {
+            if (!p)
+                return "";
+            const withoutQuery = p.split(/[?#]/)[0];
+            if (withoutQuery.length > 1 && withoutQuery.endsWith("/")) {
+                return withoutQuery.slice(0, -1);
+            }
+            return withoutQuery;
+        };
+        const matches = (itemHref, cur) => {
+            if (!itemHref || !cur)
+                return false;
+            const a = normalize(itemHref);
+            const b = normalize(cur);
+            if (!a)
+                return false;
+            if (a === b)
+                return true;
+            return b.startsWith(a + "/");
+        };
+        const base = this.getAllSections();
+        if (!currentPath)
+            return base;
+        const activeId = this.getActiveItemId(currentPath);
+        if (!activeId)
+            return base;
+        return base.map((s) => ({
+            ...s,
+            items: s.items.map((it) => ({ ...it, active: it.id === activeId })),
+        }));
+    }
+    getSection(sectionId) {
+        return this.sections.get(sectionId);
+    }
+    moveSectionToFront(sectionId) {
+        const sec = this.sections.get(sectionId);
+        if (!sec)
+            return;
+        const newMap = new Map();
+        newMap.set(sectionId, sec);
+        for (const [k, v] of this.sections.entries()) {
+            if (k === sectionId)
+                continue;
+            newMap.set(k, v);
+        }
+        this.sections = newMap;
+    }
+};
+exports.NavigationService = NavigationService;
+exports.NavigationService = NavigationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], NavigationService);

package/dist/core/router.module.d.ts

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

package/dist/core/router.module.js

@@ -0,0 +1,21 @@
+"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.RouterModule = void 0;
+const common_1 = require("@nestjs/common");
+const navigation_service_1 = require("./navigation.service");
+let RouterModule = class RouterModule {
+};
+exports.RouterModule = RouterModule;
+exports.RouterModule = RouterModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [navigation_service_1.NavigationService],
+        exports: [navigation_service_1.NavigationService],
+    })
+], RouterModule);

package/dist/core/static-assets.controller.d.ts

@@ -0,0 +1,4 @@
+import { FastifyReply } from "fastify";
+export declare class StaticAssetsController {
+    liveReloadScript(reply: FastifyReply): void;
+}