@alpaca-headless/alpaca-headless 1.0.471

package/dist/middleware/handleRequest.js

@@ -0,0 +1,38 @@
+import { resolveRoute } from "../route-data/resolve-route";
+export async function handleRequest({ request, mapHost, renderOptions, }) {
+    if (renderOptions)
+        throw new Error("Just a dummy to keep nextjs compiler happy. Remove with react 19 ");
+    const urlSearchParams = new URLSearchParams(request.nextUrl.search);
+    const nextSearchParams = {};
+    for (const [key, value] of urlSearchParams.entries()) {
+        nextSearchParams[key] = value;
+    }
+    const routeData = await resolveRoute({
+        path: request.nextUrl.pathname,
+        searchParams: nextSearchParams,
+        host: mapHost(request.headers.get("host") || ""),
+        renderOptions,
+        renderings: {},
+    });
+    if (routeData.result.type === "redirect") {
+        return new Response(null, {
+            status: routeData.result.redirectType === "permanent" ? 301 : 302,
+            headers: {
+                Location: routeData.result.location,
+            },
+        });
+    }
+    if (routeData.result.type === "unauthorized") {
+        if (routeData.result.auth)
+            return new Response(null, {
+                status: 401,
+                headers: {
+                    "WWW-Authenticate": routeData.result.auth.replace(", Bearer", ""),
+                },
+            });
+        else
+            return new Response(null, {
+                status: 401,
+            });
+    }
+}

package/dist/middleware/index.d.ts

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

package/dist/middleware/index.js

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

package/dist/picture-shared.d.ts

@@ -0,0 +1,16 @@
+import { PictureVariant } from "./types/fieldTypes";
+export type PictureParams = {
+    variant?: string;
+    aspectRatio?: number;
+    scales?: number[];
+    maxWidth?: number;
+    custom?: {
+        [paramName: string]: string | number | boolean | undefined;
+    };
+};
+export type MediaPictureParams = {
+    default: PictureParams;
+    [mediaQuery: string]: PictureParams;
+};
+export declare function getRenderedPictureVariant(params: PictureParams, variants: PictureVariant[]): PictureVariant;
+export declare function getBestMatchingVariant(variants: PictureVariant[], aspectRatio: number | undefined): PictureVariant;

package/dist/picture-shared.js

@@ -0,0 +1,26 @@
+export function getRenderedPictureVariant(params, variants) {
+    var _a, _b;
+    const variantName = (_a = params.variant) !== null && _a !== void 0 ? _a : "auto";
+    const variant = variantName.toLocaleLowerCase() === "auto" && params.aspectRatio
+        ? getBestMatchingVariant(variants, params.aspectRatio)
+        : (_b = variants.find((v) => v.name.toLowerCase() == variantName.toLowerCase())) !== null && _b !== void 0 ? _b : variants[0];
+    return variant;
+}
+export function getBestMatchingVariant(variants, aspectRatio) {
+    var _a;
+    if (!aspectRatio)
+        return ((_a = variants.find((v) => v.name.toLowerCase() == "default")) !== null && _a !== void 0 ? _a : variants[0]);
+    let minDistance = 1000000;
+    let bestMatch = undefined;
+    for (let i = 0; i < variants.length; i++) {
+        const variant = variants[i];
+        if (!variant.src)
+            continue;
+        const distance = Math.abs(aspectRatio - variant.aspectRatio);
+        if (distance < minDistance) {
+            minDistance = distance;
+            bestMatch = variant;
+        }
+    }
+    return bestMatch !== null && bestMatch !== void 0 ? bestMatch : variants[0];
+}

package/dist/render-context.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="react" />
+import { Rendering } from "./renderings/renderings";
+import { ApiConfig } from "./services/api";
+import { ComponentData, Dictionary, Page, RenderingReference, RenderingsMap } from "./types/layoutDataTypes";
+export type RenderOptions = {
+    lazyPlaceholders?: LazyPlaceholder[];
+};
+export type LazyPlaceholder = {
+    name: string;
+    numEagerComponents?: number;
+};
+export type ClientRenderContext = {
+    page: Page;
+    dictionary: Dictionary;
+    mode: string;
+    isEditing: boolean;
+    isPreview: boolean;
+    timings: Timings;
+};
+export type ContextBase = {
+    isError?: boolean;
+};
+export type Timings = {
+    [key: string]: number;
+};
+export type ServerRenderContext = ContextBase & ClientRenderContext & {
+    isError: false;
+    renderings: RenderingsMap;
+    renderOptions: RenderOptions;
+    timings: Timings;
+    resolveRendering: (rendering: RenderingReference) => Promise<any>;
+};
+export declare function createRenderContext({ page, renderings, renderOptions, compileRendering, timings, mode, apiConfig, }: {
+    page: Page;
+    renderings: RenderingsMap;
+    renderOptions?: RenderOptions;
+    timings?: Timings;
+    compileRendering?: (rendering: Rendering) => Promise<React.ComponentType<any> | null>;
+    mode: string;
+    apiConfig?: ApiConfig;
+}): Promise<ServerRenderContext>;
+export type RenderingProps = {
+    context: ServerRenderContext;
+    component: ComponentData;
+    index: number;
+    count: number;
+};

package/dist/render-context.js

@@ -0,0 +1,33 @@
+import { loadDictionary } from "./route-data/dictionary";
+export async function createRenderContext({ page, renderings, renderOptions, compileRendering, timings, mode, apiConfig, }) {
+    const startDictionaryTime = performance.now();
+    const dictionary = page
+        ? await loadDictionary(page.site.name, page.language, page.mode, apiConfig)
+        : undefined;
+    if (timings) {
+        const dictionaryTime = performance.now() - startDictionaryTime;
+        timings["dictionary"] = dictionaryTime;
+    }
+    const context = {
+        dictionary: dictionary,
+        page,
+        mode,
+        isEditing: mode === "edit",
+        isPreview: mode === "preview",
+        renderings,
+        isError: false,
+        renderOptions: renderOptions || {},
+        resolveRendering: (renderingReference) => {
+            if (compileRendering === undefined)
+                throw new Error("compileRendering is not defined" + renderingReference);
+            // return alpacaHeadless.configuration.getRenderingById(
+            //   renderingReference,
+            //   compileRendering
+            // );
+            // TODO
+            return Promise.resolve(null);
+        },
+        timings: timings || {},
+    };
+    return context;
+}

package/dist/renderings/renderings.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { RenderingReference } from "../types/layoutDataTypes.js";
+export type Rendering = {
+    code: string;
+};
+export declare function getRenderingById(renderingReference: RenderingReference, compileRendering: (rendering: Rendering) => Promise<React.ComponentType<any> | null>): Promise<React.ComponentType<any> | null>;
+export declare function getRendering(id: string): Promise<Rendering | undefined>;

package/dist/renderings/renderings.js

@@ -0,0 +1,22 @@
+import { apiGet } from "../services/api";
+export async function getRenderingById(renderingReference, compileRendering) {
+    let cache = globalThis.alpacaRenderingCache ||
+        (globalThis.alpacaRenderingCache = {});
+    const id = renderingReference.id;
+    if (id in cache && cache[id].revision === renderingReference.revision) {
+        return cache[id].rendering;
+    }
+    const rendering = await getRendering(id);
+    if (!rendering)
+        return null;
+    const compiledRendering = await compileRendering(rendering);
+    cache[id] = { compiledRendering, revision: renderingReference.revision };
+    return compiledRendering;
+}
+export async function getRendering(id) {
+    const result = await apiGet("/alpaca/headless/component/rendering?id=" + id);
+    if (result.error) {
+        console.log("Could not load rendering " + id + " Response: " + result.error);
+    }
+    return result.data;
+}

package/dist/renderings/tailwind.d.ts

@@ -0,0 +1 @@
+export declare function runTailwind(tsxContent: string): Promise<string>;

package/dist/renderings/tailwind.js

@@ -0,0 +1,43 @@
+import { writeFile, mkdir, readFile, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { promisify } from "util";
+import { exec } from "child_process";
+import { randomBytes } from "crypto";
+const execAsync = promisify(exec);
+export async function runTailwind(tsxContent) {
+    const randomString = randomBytes(8).toString("hex");
+    const dir = join(tmpdir(), `tailwind-${Date.now()}-${randomString}`);
+    const tempDir = await mkdir(dir, {
+        recursive: true,
+    });
+    if (!tempDir)
+        throw new Error("Could not create temp directory");
+    try {
+        const tsxFilePath = join(tempDir, "Component.tsx");
+        await writeFile(tsxFilePath, tsxContent);
+        const tailwindConfigPath = join(tempDir, "tailwind.config.js");
+        const tailwindConfigContent = `
+module.exports = {
+  content: ["./*.tsx"],  
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+    `;
+        await writeFile(tailwindConfigPath, tailwindConfigContent);
+        const inputCssPath = join(tempDir, "input.css");
+        const inputCssContent = "@tailwind components; @tailwind utilities;";
+        await writeFile(inputCssPath, inputCssContent);
+        const outputCssPath = join(tempDir, "output.css");
+        await execAsync("npx tailwindcss " +
+            ["-i", inputCssPath, "-o", outputCssPath, "--minify"].join(" "), { encoding: "utf8", cwd: tempDir });
+        const generatedCss = await readFile(outputCssPath, "utf8");
+        return generatedCss;
+    }
+    finally {
+        //Cleanup: remove the temporary directory
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/route-data/dictionary.d.ts

@@ -0,0 +1,2 @@
+import { ApiConfig } from "../services/api";
+export declare function loadDictionary(siteName: string, language: string, mode: string, apiConfig?: ApiConfig): Promise<any>;

package/dist/route-data/dictionary.js

@@ -0,0 +1,31 @@
+import { apiGet } from "../services/api";
+const dictionaryCache = {};
+const cacheExpirationTime = 60000;
+export async function loadDictionary(siteName, language, mode, apiConfig) {
+    const cacheKey = siteName + "_#_" + language;
+    if (mode !== "edit" &&
+        dictionaryCache[cacheKey] &&
+        dictionaryCache[cacheKey].timestamp <
+            new Date(Date.now() + cacheExpirationTime)) {
+        return dictionaryCache[cacheKey].dictionary;
+    }
+    let url = "/alpaca/headless/dictionary" +
+        (mode === "edit" ? "/editable" : "") +
+        "?siteName=" +
+        siteName +
+        "&language=" +
+        language;
+    console.log(`Fetching dictionary from ${url}.`);
+    const response = await apiGet(url, apiConfig);
+    if (response.error) {
+        console.log("Could not load dictionary: Response code: " + response.status);
+        console.log(response.error);
+        return {};
+    }
+    const dictionary = await response.data;
+    dictionaryCache[cacheKey] = {
+        dictionary: dictionary,
+        timestamp: new Date(),
+    };
+    return dictionary;
+}

package/dist/route-data/resolve-route.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+import { RenderOptions } from "..";
+import { ApiConfig } from "../services/api";
+import { ItemDescriptor } from "../types/items";
+import { RenderMode, RenderingsMap } from "../types/layoutDataTypes";
+import { PageResult, Result, RouteData } from "./route-data";
+type CacheEntry = {
+    result: Promise<Result>;
+    expiresOn: Date;
+};
+declare global {
+    var alpacaRouteDataCache: {
+        [key: string]: CacheEntry;
+    };
+}
+export type GetPageParams = {
+    itemId: string;
+    language: string;
+    version: number;
+    siteName: string;
+    renderOptions: RenderOptions;
+    renderings: RenderingsMap;
+    compileRendering?: (rendering: {
+        code: string;
+    }) => Promise<React.ComponentType<any> | null>;
+    mode: RenderMode;
+    searchParams: any;
+    apiConfig?: ApiConfig;
+};
+export declare function getPage({ itemId, language, version, siteName, renderOptions, renderings, compileRendering, mode, searchParams, apiConfig, }: GetPageParams): Promise<RouteData>;
+export type ResolveRouteParams = {
+    path: string[] | string;
+    searchParams: any;
+    host: string;
+    renderOptions: RenderOptions;
+    renderings: RenderingsMap;
+    compileRendering?: (rendering: {
+        code: string;
+    }) => Promise<React.ComponentType<any> | null>;
+    apiConfig?: ApiConfig;
+};
+export declare function resolveRoute({ path, searchParams, host, renderOptions, renderings, compileRendering, apiConfig, }: ResolveRouteParams): Promise<RouteData>;
+export declare const loadPartialLayout: (itemId: string, language: string, version: number, component: ItemDescriptor | undefined, placeholderKey: string, options: RenderOptions, siteName: string, mode: string) => Promise<PageResult | null>;
+export {};

package/dist/route-data/resolve-route.js

@@ -0,0 +1,123 @@
+import { createRenderContext } from "../render-context";
+import { apiPostObject } from "../services/api";
+if (!globalThis.alpacaRouteDataCache) {
+    globalThis.alpacaRouteDataCache = {};
+}
+const fetchRouteData = async (path, host, mode, itemId, language, version, options, apiConfig, editRevision, siteName) => {
+    var _a;
+    const cache = globalThis.alpacaRouteDataCache;
+    const cacheKey = editRevision + itemId + language + version + siteName + path + host + mode;
+    if (cacheKey && ((_a = cache[cacheKey]) === null || _a === void 0 ? void 0 : _a.expiresOn) > new Date()) {
+        Object.keys(cache).forEach((key) => {
+            if (cache[key].expiresOn < new Date()) {
+                delete cache[key];
+            }
+        });
+        return Object.assign({}, (await cache[cacheKey].result));
+    }
+    const cacheEntry = (cache[cacheKey] = {
+        result: doFetchRouteData(path, host, mode, itemId, language, version, options, apiConfig, siteName),
+        expiresOn: new Date(Date.now() + 1000 * 5),
+    });
+    return Object.assign({}, (await cacheEntry.result));
+};
+const doFetchRouteData = async (path, host, mode, itemId, language, version, options, apiConfig, siteName) => {
+    const request = {
+        path,
+        host,
+        mode,
+        itemId,
+        language,
+        version,
+        siteName,
+        options,
+    };
+    console.log(`@Fetching page layout. Host:${request.host} Path: ${request.path}`, request);
+    const startTime = performance.now();
+    const response = await apiPostObject("/alpaca/headless/layout", request, apiConfig);
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+    console.log(`@Page layout fetched in ${duration}ms. Result:`, response.status);
+    if (response.status === 200) {
+        const data = await response.data;
+        const result = Object.assign(Object.assign({}, data), { type: "page", duration });
+        if (result.timings)
+            result.timings["network"] =
+                result.duration - result.timings["totalLayout"];
+        return result;
+    }
+    if (response.status === 401) {
+        var auth = response.headers.get("WWW-Authenticate");
+        return { type: "unauthorized", auth: auth, duration };
+    }
+    if (response.status === 404) {
+        return {
+            type: "notfound",
+            duration,
+        };
+    }
+    if (response.status === 301 || response.status === 302) {
+        return {
+            type: "redirect",
+            location: response.headers.get("Location"),
+            redirectType: response.status === 301 ? "permanent" : "temporary",
+            duration,
+        };
+    }
+    console.log("@Error: ", response.error || "Unknown error", response.status);
+    return {
+        type: "error",
+        errorCode: response.status,
+        message: response.error || "Unknown error",
+        duration,
+    };
+};
+export async function getPage({ itemId, language, version, siteName, renderOptions, renderings, compileRendering, mode, searchParams, apiConfig, }) {
+    const result = await fetchRouteData("", "", mode || "normal", itemId, language, version, renderOptions, apiConfig, searchParams["edit_rev"], siteName);
+    return await createRouteData(result, renderings, renderOptions, mode, apiConfig, compileRendering);
+}
+async function createRouteData(result, renderings, renderOptions, mode, apiConfig, compileRendering) {
+    const context = result.type === "page"
+        ? await createRenderContext({
+            page: result.page,
+            renderings: renderings,
+            compileRendering: compileRendering,
+            renderOptions: renderOptions,
+            mode,
+            apiConfig,
+        })
+        : undefined;
+    // const mapStart = performance.now();
+    // if (result.type === "page" && context) {
+    //   mapContext(context, result.page);
+    // }
+    // const mapEnd = performance.now();
+    // console.log(`@Map context took ${mapEnd - mapStart}ms`);
+    return {
+        result,
+        context: context,
+    };
+}
+export async function resolveRoute({ path, searchParams, host, renderOptions, renderings, compileRendering, apiConfig, }) {
+    var _a;
+    const mode = searchParams["mode"] || "normal";
+    const result = await fetchRouteData(Array.isArray(path) ? (_a = path === null || path === void 0 ? void 0 : path.join("/")) !== null && _a !== void 0 ? _a : "/" : (path || "/"), host, mode, searchParams["itemid"] || searchParams["itemId"], searchParams["lang"], parseInt(searchParams["version"]), renderOptions, apiConfig, searchParams["edit_rev"]);
+    return await createRouteData(result, renderings, renderOptions, mode, apiConfig, compileRendering);
+}
+export const loadPartialLayout = async (itemId, language, version, component, placeholderKey, options, siteName, mode) => {
+    const request = {
+        ItemId: itemId,
+        Language: language,
+        Version: version,
+        Options: options,
+        Component: component,
+        Placeholder: placeholderKey,
+        SiteName: siteName,
+        Mode: mode,
+    };
+    const result = await apiPostObject("/alpaca/headless/layout/partial", request);
+    const data = result.data;
+    if (!data || !("page" in data))
+        return null;
+    return data;
+};

package/dist/route-data/route-data.d.ts

@@ -0,0 +1,41 @@
+import { ServerRenderContext } from "../render-context";
+import { Dictionary, Page } from "../types/layoutDataTypes";
+export type BaseResult = {
+    type: "page" | "redirect" | "error" | "notfound" | "unauthorized";
+    timings?: {
+        [key: string]: number;
+    };
+};
+export type PageResult = BaseResult & {
+    type: "page";
+    page: Page;
+};
+export type UnauthorizedResult = BaseResult & {
+    type: "unauthorized";
+    auth: string | null;
+};
+export type RedirectResult = BaseResult & {
+    type: "redirect";
+    location: string;
+    redirectType: "permanent" | "temporary";
+};
+export type ErrorResult = BaseResult & {
+    type: "error";
+    message: string;
+    errorCode: number;
+};
+export type NotFoundResult = BaseResult & {
+    type: "notfound";
+};
+export type Result = PageResult | UnauthorizedResult | RedirectResult | ErrorResult | NotFoundResult;
+export type RouteData = {
+    context?: ServerRenderContext;
+    result: Result;
+};
+export type EditorRouteData = {
+    result: Result;
+    dictionary?: Dictionary;
+    timings?: {
+        [key: string]: number;
+    };
+};

package/dist/route-data/route-data.js

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

package/dist/services/api.d.ts

@@ -0,0 +1,18 @@
+import "server-only";
+export type FetchOptions = {
+    tags?: string[];
+    revalidate?: number | false;
+};
+export type FetchResult = {
+    status: number;
+    error?: string;
+    data?: any;
+    headers: Headers;
+};
+export type ApiConfig = {
+    apiKey?: string;
+    headers?: Headers;
+};
+export declare function apiGet(route: string, config?: ApiConfig): Promise<FetchResult>;
+export declare function apiPostObject(route: string, object: any, config?: ApiConfig): Promise<FetchResult>;
+export declare function getApiKey(): string | undefined;

package/dist/services/api.js

@@ -0,0 +1,103 @@
+import "server-only";
+import axios from "axios";
+export async function apiGet(route, config) {
+    const url = process.env.LAYOUT_SERVICE_URL + route;
+    const requestHeaders = getRequestHeaders(config);
+    try {
+        const response = await axios.get(url, {
+            headers: requestHeaders,
+        });
+        return {
+            data: response.data,
+            status: response.status,
+            headers: convertAxiosHeaders(response.headers),
+        };
+    }
+    catch (error) {
+        if (error.response) {
+            return {
+                status: error.response.status,
+                error: error.response.statusText,
+                headers: convertAxiosHeaders(error.response.headers),
+            };
+        }
+        else {
+            return {
+                status: 500,
+                error: error.message,
+                headers: convertAxiosHeaders(error.response.headers),
+            };
+        }
+    }
+}
+function getRequestHeaders(config) {
+    var _a;
+    const requestHeaders = {};
+    // Convert Headers (node-fetch) to AxiosRequestHeaders (plain object)
+    if (config === null || config === void 0 ? void 0 : config.headers) {
+        config.headers.forEach((value, key) => {
+            requestHeaders[key] = value;
+        });
+    }
+    // Set default headers
+    requestHeaders["Content-Type"] = "application/json";
+    requestHeaders["x-api-key"] = (_a = config === null || config === void 0 ? void 0 : config.apiKey) !== null && _a !== void 0 ? _a : getApiKey();
+    return requestHeaders;
+}
+export async function apiPostObject(route, object, config) {
+    const url = process.env.LAYOUT_SERVICE_URL + route;
+    const requestHeaders = getRequestHeaders(config);
+    const body = JSON.stringify(object);
+    try {
+        const response = await axios.post(url, body, {
+            headers: requestHeaders,
+        });
+        return {
+            data: response.data,
+            status: response.status,
+            headers: convertAxiosHeaders(response.headers),
+        };
+    }
+    catch (error) {
+        if (error.errors) {
+            let message = "";
+            error.errors.forEach((error) => {
+                message += error.message + " ";
+            });
+            return {
+                status: 500,
+                error: message,
+                headers: new Headers(),
+            };
+        }
+        if (error.response) {
+            return {
+                status: error.response.status,
+                error: error.response.statusText,
+                headers: convertAxiosHeaders(error.response.headers),
+            };
+        }
+        else {
+            return {
+                status: 500,
+                error: error.message,
+                headers: new Headers(),
+            };
+        }
+    }
+}
+export function getApiKey() {
+    const apiKey = process.env.ALPACA_HEADLESS_API_KEY || process.env.API_KEY;
+    if (!apiKey)
+        console.log("ERROR: Could not find API key environment variable: ALPACA_HEADLESS_API_KEY");
+    return apiKey;
+}
+function convertAxiosHeaders(headers) {
+    const convertedHeaders = new Headers();
+    for (const key in headers) {
+        if (headers.hasOwnProperty(key)) {
+            convertedHeaders.set(key.toLowerCase(), headers[key]);
+        }
+    }
+    return convertedHeaders;
+}

package/dist/services/graphQL.d.ts

@@ -0,0 +1,29 @@
+import { ApiConfig } from "./api";
+export type ExecuteGraphQLParams = {
+    query: string;
+    tags?: string[];
+    host?: string;
+    path?: string;
+    language?: string;
+    mode?: string;
+    itemId?: string;
+    version?: number;
+    revalidate?: number;
+    siteName?: string;
+    sessionId?: string;
+    schema?: string;
+    apiConfig?: ApiConfig;
+};
+export declare function executeGraphQLQuery({ query, host, path, language, mode, itemId, version, siteName, schema, sessionId, apiConfig, }: ExecuteGraphQLParams): Promise<{
+    status: number;
+    errors: any;
+    data?: undefined;
+} | {
+    data: any;
+    status: number;
+    errors: any;
+}>;
+export declare function getGraphQLSchema({ id, apiConfig, }: {
+    id: string;
+    apiConfig: ApiConfig;
+}): Promise<any>;