@alpaca-headless/alpaca-headless-nextjs 1.0.129 → 1.0.253

package/dist/esm/renderContext.js

@@ -0,0 +1,49 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { loadDictionary, loadRouteData } from "./loadRouteData";
+export function createRenderContext({ path, searchParams, host, renderings, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const page = yield loadRouteData({
+            path,
+            searchParams,
+            host,
+        });
+        if (page.type !== "page") {
+            return {
+                isError: true,
+                message: `Error loading page data: ${path}`,
+                error: page,
+            };
+        }
+        const mode = searchParams["mode"] || "normal";
+        const session = searchParams["session"];
+        const dictionary = yield loadDictionary(page.site.name, page.language, mode, session);
+        const context = {
+            dictionary: dictionary,
+            page: page,
+            mode,
+            isEditing: mode === "edit",
+            isPreview: mode === "preview",
+            renderings,
+            isError: false,
+        };
+        return context;
+    });
+}
+export function createClientContext(context) {
+    const clientContext = {
+        page: context.page,
+        dictionary: context.dictionary,
+        isEditing: context.isEditing,
+        isPreview: context.isPreview,
+        mode: context.mode,
+    };
+    return clientContext;
+}

package/dist/esm/renderings.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// import { writeFile } from "fs/promises";
+// import path from "path";
+// import { tmpdir } from "os";
+// import uuid from "react-uuid";
+import React from "react";
+import ts from "typescript";
+import AlpacaHeadlessNextjs from "./public";
+export function getRenderingById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rendering = yield getRendering(id);
+        if (!rendering)
+            return () => {
+                return "Nix gefunden";
+            };
+        console.log("C O D E " + rendering.code);
+        //   const dynamicComponentCode = compileTSX(`
+        // import React from 'react';
+        // const DynamicComponent = () => <div>Hello, dynamic world!</div>;
+        // export default DynamicComponent;
+        // `);
+        const dynamicComponentCode = compileTSX(rendering.code);
+        console.log("Compiled: " + dynamicComponentCode);
+        const requires = (name) => {
+            if (name === "react")
+                return React;
+            if (name === "@alpaca-headless/alpaca-headless-nextjs")
+                return AlpacaHeadlessNextjs;
+            throw new Error(`Unresolved dependency: ${name}`);
+        };
+        const exports = {};
+        const module = { exports };
+        const func = new Function("require", "module", "exports", dynamicComponentCode);
+        func(requires, module, exports);
+        return exports.default;
+        //return fn as React.ComponentType<any>;
+        //const result = await importModuleFromString(rendering.code);
+        //return result.default as React.ComponentType<any>;
+    });
+}
+export function getRendering(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = process.env.LAYOUT_SERVICE_URL + "/alpaca/headless/component?id=" + id;
+        const response = yield fetch(url, {
+            method: "GET",
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        console.log(response.status);
+        const json = yield response.json();
+        return json;
+    });
+}
+// async function importModuleFromString(code: string) {
+//   // const moduleId = uuid();
+//   // const filePath = path.join(tmpdir(), `${moduleId}.js`);
+//   // await writeFile(filePath, code, "utf8");
+//   //console.log(code + "üüüüü");
+//   // const module = await import(
+//   //   "C:\\Hinnerk\\Alpaca-103\\Headless\\next-headless\\src\\app\\[[...path]]\\2609ed48-b9ef-7d82-29b9-6422c935c514.js"
+//   // );
+//   // Use the imported module here
+//   return module;
+// }
+function compileTSX(tsxCode) {
+    const result = ts.transpileModule(tsxCode, {
+        compilerOptions: {
+            jsx: ts.JsxEmit.React,
+            esModuleInterop: true,
+            module: ts.ModuleKind.CommonJS,
+        },
+    });
+    return result.outputText;
+}

package/dist/esm/servertypes.js

@@ -0,0 +1 @@
+export * from "./fieldTypes";

package/dist/esm/translate.js

@@ -0,0 +1,7 @@
+export function translate(text, context) {
+    const dictionary = context.dictionary;
+    const value = dictionary[text];
+    if (typeof value === "string")
+        return value;
+    return context.dictionary[text].value || text;
+}