@harpy-js/core 0.4.7

package/dist/core/static-assets.controller.js

@@ -0,0 +1,51 @@
+"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.StaticAssetsController = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class StaticAssetsController {
+    liveReloadScript(reply) {
+        const scriptPath = path.join(__dirname, "live-reload-client.js");
+        if (fs.existsSync(scriptPath)) {
+            const script = fs.readFileSync(scriptPath, "utf-8");
+            reply.type("application/javascript").send(script);
+        }
+        else {
+            reply.code(404).send("Live reload script not found");
+        }
+    }
+}
+exports.StaticAssetsController = StaticAssetsController;

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

@@ -0,0 +1,22 @@
+export interface NavItem {
+    id: string;
+    title: string;
+    href?: string;
+    active?: boolean;
+    order?: number;
+}
+export interface NavSection {
+    id: string;
+    title: string;
+    items: NavItem[];
+    order?: number;
+}
+export interface NavigationRegistry {
+    registerSection(section: NavSection): void;
+    addItemToSection(sectionId: string, item: NavItem): void;
+    registerItem(item: NavItem): void;
+    getSectionsForRoute(currentPath?: string): NavSection[];
+    getActiveItemId(currentPath?: string): string | undefined;
+    getAllSections(): NavSection[];
+    getSection(sectionId: string): NavSection | undefined;
+}

package/dist/core/types/nav.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/views/layout.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { JsxLayoutProps } from "../jsx.engine";
+export default function DefaultLayout({ children, meta, hydrationScripts, }: JsxLayoutProps & {
+    hydrationScripts?: Array<{
+        componentName: string;
+        path: string;
+    }>;
+}): React.JSX.Element;

package/dist/core/views/layout.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = DefaultLayout;
+const react_1 = __importDefault(require("react"));
+function DefaultLayout({ children, meta, hydrationScripts, }) {
+    const title = meta?.title ?? "My App";
+    const description = meta?.description ?? "Default app description";
+    const canonical = meta?.canonical ?? "https://example.com";
+    const og = meta?.openGraph ?? {};
+    const twitter = meta?.twitter ?? {};
+    const chunkScripts = hydrationScripts || [];
+    return (react_1.default.createElement("html", { lang: "en" },
+        react_1.default.createElement("head", null,
+            react_1.default.createElement("title", null, title),
+            react_1.default.createElement("meta", { charSet: "utf-8" }),
+            react_1.default.createElement("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+            react_1.default.createElement("link", { rel: "stylesheet", href: "/styles/styles.css" }),
+            react_1.default.createElement("meta", { name: "description", content: description }),
+            react_1.default.createElement("link", { rel: "canonical", href: canonical }),
+            og.title && react_1.default.createElement("meta", { property: "og:title", content: og.title }),
+            og.description && (react_1.default.createElement("meta", { property: "og:description", content: og.description })),
+            og.type && react_1.default.createElement("meta", { property: "og:type", content: og.type }),
+            og.image && react_1.default.createElement("meta", { property: "og:image", content: og.image }),
+            og.url && react_1.default.createElement("meta", { property: "og:url", content: og.url }),
+            twitter.card && react_1.default.createElement("meta", { name: "twitter:card", content: twitter.card }),
+            twitter.title && react_1.default.createElement("meta", { name: "twitter:title", content: twitter.title }),
+            twitter.description && (react_1.default.createElement("meta", { name: "twitter:description", content: twitter.description })),
+            twitter.image && react_1.default.createElement("meta", { name: "twitter:image", content: twitter.image })),
+        react_1.default.createElement("body", { className: "bg-slate-50" },
+            react_1.default.createElement("main", { id: "body", className: "min-h-screen" }, children),
+            chunkScripts.map((script) => (react_1.default.createElement("script", { key: script.componentName, src: script.path }))))));
+}

package/dist/decorators/jsx.decorator.d.ts

@@ -0,0 +1,26 @@
+import { JsxLayout } from "../core/jsx.engine";
+export interface MetaOptions {
+    title?: string;
+    description?: string;
+    canonical?: string;
+    openGraph?: {
+        title?: string;
+        description?: string;
+        type?: string;
+        image?: string;
+        url?: string;
+    };
+    twitter?: {
+        card?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+    };
+}
+export interface RenderOptions {
+    layout?: JsxLayout;
+    bootstrapScripts?: string[];
+    meta?: MetaResolver;
+}
+export type MetaResolver<T = any> = MetaOptions | ((req: any, data: T) => MetaOptions | Promise<MetaOptions>);
+export declare function JsxRender<T>(template: (data: T) => React.JSX.Element, options?: RenderOptions): MethodDecorator;

package/dist/decorators/jsx.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsxRender = JsxRender;
+const constants_1 = require("@nestjs/common/constants");
+function JsxRender(template, options = {}) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.RENDER_METADATA, [template, options], descriptor.value);
+        return descriptor;
+    };
+}

package/dist/decorators/layout.decorator.d.ts

@@ -0,0 +1,4 @@
+import { JsxLayout } from "../core/jsx.engine";
+export declare const LAYOUT_METADATA = "harpy:layout";
+export declare function WithLayout(layout: JsxLayout): ClassDecorator & MethodDecorator;
+export declare function getLayoutForHandler(handler: Function, controllerClass: Function): JsxLayout | undefined;

package/dist/decorators/layout.decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYOUT_METADATA = void 0;
+exports.WithLayout = WithLayout;
+exports.getLayoutForHandler = getLayoutForHandler;
+exports.LAYOUT_METADATA = "harpy:layout";
+function WithLayout(layout) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey && descriptor) {
+            Reflect.defineMetadata(exports.LAYOUT_METADATA, layout, descriptor.value);
+            return descriptor;
+        }
+        else {
+            Reflect.defineMetadata(exports.LAYOUT_METADATA, layout, target);
+            return target;
+        }
+    };
+}
+function getLayoutForHandler(handler, controllerClass) {
+    const methodLayout = Reflect.getMetadata(exports.LAYOUT_METADATA, handler);
+    if (methodLayout) {
+        return methodLayout;
+    }
+    const controllerLayout = Reflect.getMetadata(exports.LAYOUT_METADATA, controllerClass);
+    if (controllerLayout) {
+        return controllerLayout;
+    }
+    return undefined;
+}

package/dist/i18n/__tests__/i18n.helper.test.d.ts

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

package/dist/i18n/__tests__/i18n.helper.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const i18n_helper_1 = require("../i18n.helper");
+const i18n_module_options_1 = require("../i18n-module.options");
+describe("I18nHelper", () => {
+    let helper;
+    const mockOptions = {
+        defaultLocale: "en",
+        locales: ["en", "fr", "es"],
+        urlPattern: "query",
+        translationsPath: "./dictionaries",
+        cookieName: "locale",
+        queryParam: "lang",
+    };
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            providers: [
+                i18n_helper_1.I18nHelper,
+                {
+                    provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                    useValue: mockOptions,
+                },
+            ],
+        }).compile();
+        helper = module.get(i18n_helper_1.I18nHelper);
+    });
+    describe("buildLocaleUrl", () => {
+        describe("query pattern", () => {
+            it("should build URL with query parameter", () => {
+                const url = helper.buildLocaleUrl("fr", "/home");
+                expect(url).toBe("/home?lang=fr");
+            });
+            it("should preserve existing query parameters", () => {
+                const url = helper.buildLocaleUrl("fr", "/home", { page: "2" });
+                expect(url).toContain("lang=fr");
+                expect(url).toContain("page=2");
+            });
+            it("should replace existing lang parameter", () => {
+                const url = helper.buildLocaleUrl("fr", "/home", { lang: "en" });
+                expect(url).toBe("/home?lang=fr");
+            });
+        });
+        describe("header pattern", () => {
+            beforeEach(async () => {
+                const module = await testing_1.Test.createTestingModule({
+                    providers: [
+                        i18n_helper_1.I18nHelper,
+                        {
+                            provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                            useValue: { ...mockOptions, urlPattern: "header" },
+                        },
+                    ],
+                }).compile();
+                helper = module.get(i18n_helper_1.I18nHelper);
+            });
+            it("should return path without query for header pattern", () => {
+                const url = helper.buildLocaleUrl("fr", "/home");
+                expect(url).toBe("/home");
+            });
+            it("should preserve existing query parameters", () => {
+                const url = helper.buildLocaleUrl("fr", "/home", { page: "2" });
+                expect(url).toBe("/home?page=2");
+            });
+        });
+    });
+    describe("setLocaleCookie", () => {
+        it("should set cookie with correct name and value", () => {
+            const mockRes = {
+                setCookie: jest.fn(),
+            };
+            helper.setLocaleCookie(mockRes, "fr");
+            expect(mockRes.setCookie).toHaveBeenCalledWith("locale", "fr", expect.objectContaining({
+                path: "/",
+                maxAge: 365 * 24 * 60 * 60,
+                httpOnly: false,
+                sameSite: "lax",
+            }));
+        });
+    });
+    describe("validateLocale", () => {
+        it("should return valid locale", () => {
+            expect(helper.validateLocale("fr")).toBe("fr");
+            expect(helper.validateLocale("es")).toBe("es");
+        });
+        it("should return default locale for invalid locale", () => {
+            expect(helper.validateLocale("de")).toBe("en");
+            expect(helper.validateLocale("invalid")).toBe("en");
+        });
+        it("should return default locale for empty string", () => {
+            expect(helper.validateLocale("")).toBe("en");
+        });
+    });
+    describe("getClientConfig", () => {
+        it("should return client configuration", () => {
+            const config = helper.getClientConfig();
+            expect(config).toEqual({
+                locales: ["en", "fr", "es"],
+                defaultLocale: "en",
+                urlPattern: "query",
+                queryParam: "lang",
+            });
+        });
+    });
+});

package/dist/i18n/__tests__/i18n.interceptor.test.d.ts

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

package/dist/i18n/__tests__/i18n.interceptor.test.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const i18n_interceptor_1 = require("../i18n.interceptor");
+const i18n_module_options_1 = require("../i18n-module.options");
+const rxjs_1 = require("rxjs");
+describe("I18nInterceptor", () => {
+    let interceptor;
+    const mockOptions = {
+        defaultLocale: "en",
+        locales: ["en", "fr", "es"],
+        urlPattern: "query",
+        translationsPath: "./dictionaries",
+        cookieName: "locale",
+        queryParam: "lang",
+    };
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            providers: [
+                i18n_interceptor_1.I18nInterceptor,
+                {
+                    provide: i18n_module_options_1.I18N_MODULE_OPTIONS,
+                    useValue: mockOptions,
+                },
+            ],
+        }).compile();
+        interceptor = module.get(i18n_interceptor_1.I18nInterceptor);
+    });
+    const createMockContext = (request, response) => {
+        const mockResponse = response || {
+            header: jest.fn(),
+        };
+        return {
+            switchToHttp: () => ({
+                getRequest: () => request,
+                getResponse: () => mockResponse,
+                getNext: jest.fn(),
+            }),
+        };
+    };
+    const createMockCallHandler = () => {
+        return {
+            handle: () => (0, rxjs_1.of)({}),
+        };
+    };
+    describe("Query pattern locale detection", () => {
+        it("should extract locale from query parameter", (done) => {
+            const mockRequest = {
+                query: { lang: "fr" },
+                headers: {},
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                done();
+            });
+        });
+        it("should ignore invalid query locale", (done) => {
+            const mockRequest = {
+                query: { lang: "invalid" },
+                headers: {},
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("en");
+                done();
+            });
+        });
+    });
+    describe("Cookie locale detection", () => {
+        it("should extract locale from cookie", (done) => {
+            const mockRequest = {
+                query: {},
+                headers: {
+                    cookie: "locale=fr; other=value",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                done();
+            });
+        });
+        it("should ignore invalid cookie locale", (done) => {
+            const mockRequest = {
+                query: {},
+                headers: {
+                    cookie: "locale=invalid",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("en");
+                done();
+            });
+        });
+    });
+    describe("Header locale detection", () => {
+        it("should extract locale from x-lang header when using header pattern", (done) => {
+            const headerInterceptor = new i18n_interceptor_1.I18nInterceptor({
+                ...mockOptions,
+                urlPattern: "header",
+            });
+            const mockRequest = {
+                query: {},
+                headers: {
+                    "x-lang": "fr",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            headerInterceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                done();
+            });
+        });
+        it("should extract locale from accept-language header as fallback", (done) => {
+            const mockRequest = {
+                query: {},
+                headers: {
+                    "accept-language": "fr-FR,fr;q=0.9,en;q=0.8",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                done();
+            });
+        });
+    });
+    describe("Locale priority", () => {
+        it("should prioritize query over cookie", (done) => {
+            const mockRequest = {
+                query: { lang: "es" },
+                headers: {
+                    cookie: "locale=fr",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("es");
+                done();
+            });
+        });
+        it("should prioritize cookie over accept-language header", (done) => {
+            const mockRequest = {
+                query: {},
+                headers: {
+                    cookie: "locale=fr",
+                    "accept-language": "es-ES,es;q=0.9,en;q=0.8",
+                },
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                done();
+            });
+        });
+        it("should fall back to default locale when nothing matches", (done) => {
+            const mockRequest = {
+                query: {},
+                headers: {},
+            };
+            const context = createMockContext(mockRequest);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("en");
+                done();
+            });
+        });
+        it("should set cookie when locale is found in URL", (done) => {
+            const mockResponse = {
+                header: jest.fn(),
+            };
+            const mockRequest = {
+                query: { lang: "fr" },
+                headers: {},
+            };
+            const context = createMockContext(mockRequest, mockResponse);
+            const next = createMockCallHandler();
+            interceptor.intercept(context, next).subscribe(() => {
+                expect(mockRequest.locale).toBe("fr");
+                expect(mockResponse.header).toHaveBeenCalledWith("Set-Cookie", expect.stringContaining("locale=fr"));
+                done();
+            });
+        });
+    });
+});

package/dist/i18n/__tests__/i18n.module.test.d.ts

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

package/dist/i18n/__tests__/i18n.module.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const i18n_module_1 = require("../i18n.module");
+const i18n_service_1 = require("../i18n.service");
+const i18n_helper_1 = require("../i18n.helper");
+const i18n_switcher_controller_1 = require("../i18n-switcher.controller");
+const i18n_module_options_1 = require("../i18n-module.options");
+describe("I18nModule", () => {
+    it("should be defined", () => {
+        expect(i18n_module_1.I18nModule).toBeDefined();
+    });
+    describe("forRoot", () => {
+        it("should create a dynamic module with default options", async () => {
+            const module = i18n_module_1.I18nModule.forRoot({
+                defaultLocale: "en",
+                locales: ["en", "fr"],
+            });
+            expect(module.module).toBe(i18n_module_1.I18nModule);
+            expect(module.controllers).toContain(i18n_switcher_controller_1.I18nSwitcherController);
+            expect(module.providers).toBeDefined();
+            expect(module.exports).toBeDefined();
+        });
+        it("should provide I18nService", async () => {
+            const testModule = await testing_1.Test.createTestingModule({
+                imports: [
+                    i18n_module_1.I18nModule.forRoot({
+                        defaultLocale: "en",
+                        locales: ["en", "fr"],
+                    }),
+                ],
+            }).compile();
+            const service = await testModule.resolve(i18n_service_1.I18nService);
+            expect(service).toBeDefined();
+        });
+        it("should provide I18nHelper", async () => {
+            const testModule = await testing_1.Test.createTestingModule({
+                imports: [
+                    i18n_module_1.I18nModule.forRoot({
+                        defaultLocale: "en",
+                        locales: ["en", "fr"],
+                    }),
+                ],
+            }).compile();
+            const helper = testModule.get(i18n_helper_1.I18nHelper);
+            expect(helper).toBeDefined();
+        });
+        it("should apply default values for missing options", async () => {
+            const module = i18n_module_1.I18nModule.forRoot({
+                defaultLocale: "en",
+                locales: ["en"],
+            });
+            const optionsProvider = module.providers?.find((p) => p.provide === i18n_module_options_1.I18N_MODULE_OPTIONS);
+            expect(optionsProvider.useValue).toEqual({
+                defaultLocale: "en",
+                locales: ["en"],
+                urlPattern: "query",
+                translationsPath: "./dictionaries",
+                cookieName: "locale",
+                queryParam: "lang",
+            });
+        });
+        it("should preserve custom options", async () => {
+            const module = i18n_module_1.I18nModule.forRoot({
+                defaultLocale: "fr",
+                locales: ["fr", "en", "es"],
+                urlPattern: "header",
+                translationsPath: "../locales",
+                cookieName: "user_locale",
+                queryParam: "language",
+            });
+            const optionsProvider = module.providers?.find((p) => p.provide === i18n_module_options_1.I18N_MODULE_OPTIONS);
+            expect(optionsProvider.useValue).toEqual({
+                defaultLocale: "fr",
+                locales: ["fr", "en", "es"],
+                urlPattern: "header",
+                translationsPath: "../locales",
+                cookieName: "user_locale",
+                queryParam: "language",
+            });
+        });
+    });
+});

package/dist/i18n/__tests__/i18n.service.test.d.ts

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