@harpy-js/core 0.4.7

package/dist/core/__tests__/component-analyzer.test.js

@@ -0,0 +1,151 @@
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+jest.mock("fs");
+jest.mock("path");
+describe("Component Analyzer", () => {
+    const mockFs = fs;
+    const mockPath = path;
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("client component detection", () => {
+        it('should detect "use client" directive', () => {
+            const code = '"use client";\nexport function MyComponent() {}';
+            expect(code).toContain("use client");
+        });
+        it("should detect server components (no directive)", () => {
+            const code = "export function ServerComponent() {}";
+            expect(code).not.toContain("use client");
+        });
+        it("should handle single quotes", () => {
+            const code = "'use client';\nexport function Comp() {}";
+            expect(code).toMatch(/['"]use client['"]/);
+        });
+    });
+    describe("React hooks detection", () => {
+        it("should detect useState import", () => {
+            const code = 'import { useState } from "react";';
+            expect(code).toContain("useState");
+        });
+        it("should detect useEffect import", () => {
+            const code = 'import { useEffect } from "react";';
+            expect(code).toContain("useEffect");
+        });
+        it("should detect multiple hooks", () => {
+            const code = 'import { useState, useEffect, useRef } from "react";';
+            expect(code).toContain("useState");
+            expect(code).toContain("useEffect");
+            expect(code).toContain("useRef");
+        });
+    });
+    describe("event handler detection", () => {
+        it("should detect onClick handler", () => {
+            const code = "<button onClick={handleClick}>Click</button>";
+            expect(code).toContain("onClick");
+        });
+        it("should detect onChange handler", () => {
+            const code = "<input onChange={handleChange} />";
+            expect(code).toContain("onChange");
+        });
+        it("should detect onSubmit handler", () => {
+            const code = "<form onSubmit={handleSubmit}>";
+            expect(code).toContain("onSubmit");
+        });
+    });
+    describe("component name extraction", () => {
+        it("should extract function component name", () => {
+            const code = "export function MyComponent() {}";
+            const match = code.match(/function\s+(\w+)/);
+            expect(match).toBeDefined();
+            expect(match[1]).toBe("MyComponent");
+        });
+        it("should extract arrow function component name", () => {
+            const code = "export const MyComponent = () => {}";
+            const match = code.match(/const\s+(\w+)\s*=/);
+            expect(match).toBeDefined();
+            expect(match[1]).toBe("MyComponent");
+        });
+        it("should extract default export name", () => {
+            const code = "export default function Component() {}";
+            const match = code.match(/default\s+function\s+(\w+)/);
+            expect(match).toBeDefined();
+            expect(match[1]).toBe("Component");
+        });
+    });
+    describe("file system operations", () => {
+        it("should filter TypeScript files", () => {
+            const files = ["component.tsx", "utils.ts", "styles.css", "test.jsx"];
+            const tsxFiles = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".jsx"));
+            expect(tsxFiles).toEqual(["component.tsx", "test.jsx"]);
+        });
+        it("should handle path operations", () => {
+            const basePath = "/src";
+            const fileName = "components";
+            const fullPath = `${basePath}/${fileName}`;
+            expect(fullPath).toBe("/src/components");
+        });
+    });
+    describe("code analysis patterns", () => {
+        it("should identify React imports", () => {
+            const patterns = [
+                'import React from "react"',
+                'import * as React from "react"',
+                'import { Component } from "react"',
+            ];
+            patterns.forEach((pattern) => {
+                expect(pattern).toMatch(/import.*from\s+['"]react['"]/);
+            });
+        });
+        it("should identify JSX syntax", () => {
+            const jsxPatterns = [
+                "<div>content</div>",
+                '<Component prop="value" />',
+                "<>{children}</>",
+            ];
+            jsxPatterns.forEach((pattern) => {
+                expect(pattern).toMatch(/<[\w>]/);
+            });
+        });
+        it("should detect client-side APIs", () => {
+            const clientAPIs = ["window", "document", "localStorage", "navigator"];
+            const code = "const width = window.innerWidth;";
+            const hasClientAPI = clientAPIs.some((api) => code.includes(api));
+            expect(hasClientAPI).toBe(true);
+        });
+    });
+});

package/dist/core/__tests__/hydration-manifest.test.d.ts

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

package/dist/core/__tests__/hydration-manifest.test.js

@@ -0,0 +1,211 @@
+"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 });
+const fs = __importStar(require("fs"));
+jest.mock("fs");
+describe("Hydration Manifest", () => {
+    const mockFs = fs;
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("manifest structure", () => {
+        it("should have components array", () => {
+            const manifest = { components: [] };
+            expect(manifest).toHaveProperty("components");
+            expect(Array.isArray(manifest.components)).toBe(true);
+        });
+        it("should store component metadata", () => {
+            const component = {
+                name: "TestComponent",
+                path: "/src/TestComponent.tsx",
+                isClient: true,
+                hasState: true,
+                hasEffects: false,
+                hasEventHandlers: true,
+            };
+            expect(component.name).toBe("TestComponent");
+            expect(component.isClient).toBe(true);
+            expect(component.hasState).toBe(true);
+        });
+        it("should handle multiple components", () => {
+            const manifest = {
+                components: [
+                    { name: "Comp1", path: "/Comp1.tsx", isClient: true },
+                    { name: "Comp2", path: "/Comp2.tsx", isClient: true },
+                ],
+            };
+            expect(manifest.components).toHaveLength(2);
+        });
+    });
+    describe("client component filtering", () => {
+        it("should identify client components", () => {
+            const components = [
+                { name: "ClientComp", isClient: true },
+                { name: "ServerComp", isClient: false },
+            ];
+            const clientOnly = components.filter((c) => c.isClient);
+            expect(clientOnly).toHaveLength(1);
+            expect(clientOnly[0].name).toBe("ClientComp");
+        });
+        it("should handle all server components", () => {
+            const components = [
+                { name: "ServerComp1", isClient: false },
+                { name: "ServerComp2", isClient: false },
+            ];
+            const clientOnly = components.filter((c) => c.isClient);
+            expect(clientOnly).toHaveLength(0);
+        });
+        it("should handle all client components", () => {
+            const components = [
+                { name: "ClientComp1", isClient: true },
+                { name: "ClientComp2", isClient: true },
+            ];
+            const clientOnly = components.filter((c) => c.isClient);
+            expect(clientOnly).toHaveLength(2);
+        });
+    });
+    describe("JSON serialization", () => {
+        it("should serialize to JSON", () => {
+            const manifest = {
+                components: [
+                    {
+                        name: "TestComponent",
+                        path: "/TestComponent.tsx",
+                        isClient: true,
+                        hasState: true,
+                        hasEffects: false,
+                        hasEventHandlers: true,
+                    },
+                ],
+            };
+            const json = JSON.stringify(manifest);
+            expect(json).toContain("TestComponent");
+            expect(json).toContain("isClient");
+        });
+        it("should deserialize from JSON", () => {
+            const json = '{"components":[{"name":"Comp","path":"/Comp.tsx","isClient":true}]}';
+            const manifest = JSON.parse(json);
+            expect(manifest.components).toHaveLength(1);
+            expect(manifest.components[0].name).toBe("Comp");
+        });
+        it("should preserve component metadata", () => {
+            const original = {
+                name: "Component",
+                path: "/Component.tsx",
+                isClient: true,
+                hasState: true,
+                hasEffects: true,
+                hasEventHandlers: true,
+            };
+            const json = JSON.stringify(original);
+            const parsed = JSON.parse(json);
+            expect(parsed).toEqual(original);
+        });
+    });
+    describe("file operations", () => {
+        it("should serialize manifest for saving", () => {
+            const manifest = { components: [] };
+            const filePath = "/output/manifest.json";
+            const serialized = JSON.stringify(manifest, null, 2);
+            expect(serialized).toContain("components");
+            expect(serialized).toContain("[]");
+        });
+        it("should deserialize manifest from JSON string", () => {
+            const mockData = JSON.stringify({
+                components: [
+                    { name: "LoadedComponent", path: "/Comp.tsx", isClient: true },
+                ],
+            });
+            const manifest = JSON.parse(mockData);
+            expect(manifest.components).toHaveLength(1);
+            expect(manifest.components[0].name).toBe("LoadedComponent");
+        });
+        it("should validate file paths", () => {
+            const validPath = "/manifest.json";
+            const invalidPath = "";
+            expect(validPath.length).toBeGreaterThan(0);
+            expect(invalidPath.length).toBe(0);
+        });
+        it("should handle directory paths", () => {
+            const dirPath = "/new/directory";
+            const parts = dirPath.split("/").filter(Boolean);
+            expect(parts).toEqual(["new", "directory"]);
+            expect(parts.length).toBe(2);
+        });
+    });
+    describe("component metadata", () => {
+        it("should track component state usage", () => {
+            const component = { name: "StatefulComp", hasState: true };
+            expect(component.hasState).toBe(true);
+        });
+        it("should track component effects", () => {
+            const component = { name: "EffectComp", hasEffects: true };
+            expect(component.hasEffects).toBe(true);
+        });
+        it("should track event handlers", () => {
+            const component = { name: "InteractiveComp", hasEventHandlers: true };
+            expect(component.hasEventHandlers).toBe(true);
+        });
+        it("should combine multiple flags", () => {
+            const component = {
+                name: "ComplexComp",
+                hasState: true,
+                hasEffects: true,
+                hasEventHandlers: true,
+            };
+            expect(component.hasState).toBe(true);
+            expect(component.hasEffects).toBe(true);
+            expect(component.hasEventHandlers).toBe(true);
+        });
+    });
+    describe("deduplication", () => {
+        it("should prevent duplicate component entries", () => {
+            const components = [
+                { name: "Comp", path: "/Comp.tsx" },
+                { name: "Comp", path: "/Comp.tsx" },
+            ];
+            const unique = Array.from(new Set(components.map((c) => c.name))).map((name) => components.find((c) => c.name === name));
+            expect(unique).toHaveLength(1);
+        });
+        it("should allow same name in different paths", () => {
+            const components = [
+                { name: "Button", path: "/ui/Button.tsx" },
+                { name: "Button", path: "/forms/Button.tsx" },
+            ];
+            const uniqueByPath = Array.from(new Set(components.map((c) => c.path))).map((path) => components.find((c) => c.path === path));
+            expect(uniqueByPath).toHaveLength(2);
+        });
+    });
+});

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

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

package/dist/core/__tests__/jsx.engine.test.js

@@ -0,0 +1,118 @@
+"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 });
+const jsx_engine_1 = require("../jsx.engine");
+const React = __importStar(require("react"));
+describe("JSX Engine", () => {
+    let mockApp;
+    let mockAdapter;
+    let mockReply;
+    beforeEach(() => {
+        mockReply = {
+            raw: {
+                end: jest.fn(),
+                write: jest.fn(),
+                setHeader: jest.fn(),
+                headersSent: false,
+            },
+            statusCode: 200,
+            request: {},
+            status: jest.fn().mockReturnThis(),
+            send: jest.fn(),
+        };
+        mockAdapter = {
+            render: null,
+            get: jest.fn(),
+            post: jest.fn(),
+        };
+        mockApp = {
+            getHttpAdapter: jest.fn().mockReturnValue(mockAdapter),
+        };
+    });
+    describe("withJsxEngine", () => {
+        it("should attach render method to the adapter", () => {
+            const mockLayout = (props) => React.createElement("html", null, props.children);
+            (0, jsx_engine_1.withJsxEngine)(mockApp, mockLayout);
+            expect(mockAdapter.render).toBeDefined();
+            expect(typeof mockAdapter.render).toBe("function");
+        });
+        it("should handle redirect status codes without rendering", async () => {
+            const mockLayout = (props) => React.createElement("html", null, props.children);
+            (0, jsx_engine_1.withJsxEngine)(mockApp, mockLayout);
+            mockReply.statusCode = 301;
+            await mockAdapter.render(mockReply, [() => React.createElement("div"), {}], {});
+            expect(mockReply.raw.end).toHaveBeenCalled();
+        });
+        it("should handle error status codes without rendering", async () => {
+            const mockLayout = (props) => React.createElement("html", null, props.children);
+            (0, jsx_engine_1.withJsxEngine)(mockApp, mockLayout);
+            mockReply.statusCode = 500;
+            await mockAdapter.render(mockReply, [() => React.createElement("div"), {}], {});
+            expect(mockReply.raw.end).toHaveBeenCalled();
+        });
+        it("should accept custom layout in options", () => {
+            const defaultLayout = (props) => React.createElement("html", null, React.createElement("body", null, props.children));
+            const customLayout = (props) => React.createElement("html", null, React.createElement("main", null, props.children));
+            (0, jsx_engine_1.withJsxEngine)(mockApp, defaultLayout);
+            expect(mockAdapter.render).toBeDefined();
+            expect(typeof customLayout).toBe("function");
+        });
+        it("should support component props", () => {
+            const mockLayout = (props) => React.createElement("html", null, props.children);
+            (0, jsx_engine_1.withJsxEngine)(mockApp, mockLayout);
+            const component = (props) => React.createElement("div", null, `Hello ${props.name}`);
+            const rendered = component({ name: "Harpy" });
+            expect(rendered.props.children).toContain("Harpy");
+        });
+    });
+    describe("React rendering", () => {
+        it("should render simple React components", () => {
+            const element = React.createElement("div", null, "Hello World");
+            expect(element).toBeDefined();
+            expect(element.type).toBe("div");
+        });
+        it("should render nested components", () => {
+            const child = React.createElement("span", null, "Child");
+            const parent = React.createElement("div", null, child);
+            expect(parent).toBeDefined();
+            expect(parent.type).toBe("div");
+        });
+        it("should handle component props", () => {
+            const element = React.createElement("div", { className: "test", id: "main" }, "Content");
+            expect(element.props.className).toBe("test");
+            expect(element.props.id).toBe("main");
+        });
+    });
+});

package/dist/core/app-setup.d.ts

@@ -0,0 +1,7 @@
+import type { NestFastifyApplication } from "@nestjs/platform-fastify";
+export interface HarpyAppOptions {
+    layout?: any;
+    distDir?: string;
+}
+export declare function configureHarpyApp(app: NestFastifyApplication, opts?: HarpyAppOptions): Promise<void>;
+export declare function setupHarpyApp(app: NestFastifyApplication, opts?: HarpyAppOptions): Promise<void>;

package/dist/core/app-setup.js

@@ -0,0 +1,79 @@
+"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.configureHarpyApp = configureHarpyApp;
+exports.setupHarpyApp = setupHarpyApp;
+const path = __importStar(require("path"));
+let fastifyStatic;
+let fastifyCookie;
+try {
+    fastifyStatic = require("@fastify/static");
+}
+catch (e) {
+    fastifyStatic = undefined;
+}
+try {
+    fastifyCookie = require("@fastify/cookie");
+}
+catch (e) {
+    fastifyCookie = undefined;
+}
+const jsx_engine_1 = require("./jsx.engine");
+async function configureHarpyApp(app, opts = {}) {
+    const { layout, distDir = "dist" } = opts;
+    if (layout) {
+        (0, jsx_engine_1.withJsxEngine)(app, layout);
+    }
+    const fastify = app.getHttpAdapter().getInstance();
+    if (fastifyCookie) {
+        await fastify.register(fastifyCookie);
+    }
+    else {
+        console.warn("[harpy-core] optional dependency `@fastify/cookie` is not installed; skipping cookie registration.");
+    }
+    if (fastifyStatic) {
+        await fastify.register(fastifyStatic, {
+            root: path.join(process.cwd(), distDir),
+            prefix: "/",
+            decorateReply: false,
+        });
+    }
+    else {
+        console.warn("[harpy-core] optional dependency `@fastify/static` is not installed; static `dist` handler not registered.");
+    }
+}
+async function setupHarpyApp(app, opts = {}) {
+    return configureHarpyApp(app, opts);
+}

package/dist/core/auto-register.module.d.ts

@@ -0,0 +1,9 @@
+import { OnModuleInit } from "@nestjs/common";
+import { NavigationService } from "./navigation.service";
+import type { NavigationRegistry } from "./types/nav.types";
+export declare abstract class AutoRegisterModule implements OnModuleInit {
+    protected readonly navigationService: NavigationService;
+    constructor(navigationService: NavigationService);
+    protected abstract registerNavigation(navigation: NavigationRegistry): void;
+    onModuleInit(): void;
+}

package/dist/core/auto-register.module.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoRegisterModule = void 0;
+class AutoRegisterModule {
+    navigationService;
+    constructor(navigationService) {
+        this.navigationService = navigationService;
+    }
+    onModuleInit() {
+        try {
+            this.registerNavigation(this.navigationService);
+        }
+        catch (err) {
+            console.warn("[AutoRegisterModule] registerNavigation failed:", err);
+        }
+    }
+}
+exports.AutoRegisterModule = AutoRegisterModule;

package/dist/core/auto-wrap-middleware.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare function autoWrapIfUsesClient(component: React.ComponentType<any>): React.ComponentType<any>;
+export declare const createAutoWrapCreateElement: (originalCreateElement: typeof React.createElement) => (type: React.ElementType, props?: Record<string, any> | null, ...children: React.ReactNode[]) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function clearComponentAnalysisCache(): void;