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

package/dist/esm/editor/services/contentService.js

@@ -0,0 +1,56 @@
+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 Cookies from "universal-cookie";
+export function getChildren(itemId, sessionId, templateIds = [], includeEmbeddedItems) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/children?itemId=" +
+            itemId +
+            "&sessionId=" +
+            sessionId +
+            "&includeEmbeddedItems=" +
+            includeEmbeddedItems;
+        url = templateIds.reduce((u, t) => u + "&templateIds=" + t, url);
+        const response = yield fetch(url, {
+            method: "GET",
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        return yield response.json();
+    });
+}
+export function getItem(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/item?itemId=" +
+            item.id +
+            "&language=" +
+            item.language +
+            "&version=" +
+            item.version;
+        const response = yield fetch(url, {
+            method: "GET",
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        const json = yield response.json();
+        return json;
+    });
+}

package/dist/esm/editor/services/editService.js

@@ -0,0 +1,394 @@
+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 Cookies from "universal-cookie";
+import { post } from "./serviceHelper";
+export function connectSocket(sessionId) {
+    let loc = window.location, new_uri;
+    if (loc.protocol === "https:") {
+        new_uri = "wss:";
+    }
+    else {
+        new_uri = "ws:";
+    }
+    new_uri += "//" + loc.host;
+    return new WebSocket(new_uri + "/alpaca/headless/editor/socket?sessionId=" + sessionId);
+}
+export function getPictureValue(field, pictureRawValue, site, sessionId) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const fieldItem = (_a = field._editor) === null || _a === void 0 ? void 0 : _a.descriptor.item;
+        if (!fieldItem)
+            return;
+        const response = yield fetch("/alpaca/headless/editor/getPictureValue?sessionId=" + sessionId, {
+            method: "POST",
+            body: JSON.stringify({
+                site,
+                itemId: fieldItem.id,
+                itemLanguage: fieldItem.language,
+                itemVersion: fieldItem.version,
+                pictureFieldId: field.id,
+                pictureValue: JSON.stringify(pictureRawValue),
+            }),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        return yield response.json();
+    });
+}
+export function executeEditOperation(editOperation, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        editOperation.sessionId = sessionId;
+        const response = yield fetch("/alpaca/headless/editor/edit?sessionId=" + sessionId, {
+            method: "POST",
+            body: JSON.stringify(editOperation),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.status === 500 || response.redirected) {
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while saving changes.",
+                response,
+            };
+        }
+        if (response.status === 401) {
+            return {
+                type: "unauthenticated",
+                summary: "Unauthorized",
+                details: "Not logged in anymore?",
+                response,
+            };
+        }
+        return yield response.json();
+    });
+}
+export function executeUndo(sessionId, item, numOperations) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return post("/alpaca/headless/editor/undo", { numOperations, item: getItemDescriptor(item) }, sessionId);
+    });
+}
+export function executeRedo(sessionId, item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return post("/alpaca/headless/editor/redo", { item: getItemDescriptor(item) }, sessionId);
+    });
+}
+export function deleteItem(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return post("/alpaca/headless/editor/deleteItem", item);
+    });
+}
+function getItemDescriptor(item) {
+    return {
+        id: item.id,
+        language: item.language,
+        version: item.version,
+    };
+}
+export function lockItems(items) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield post("/alpaca/headless/editor/lock", items.map(getItemDescriptor));
+        return response;
+    });
+}
+export function unlockItems(items) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield post("/alpaca/headless/editor/unlock", items.map(getItemDescriptor));
+        return response;
+    });
+}
+export function lockField(item, fieldId, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield post("/alpaca/headless/editor/lockField", {
+            item,
+            fieldId: fieldId,
+            sessionId: sessionId,
+        });
+        return response;
+    });
+}
+export function releaseFieldLocks(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield post("/alpaca/headless/editor/releaseFieldLocks", {
+            sessionId,
+        });
+        return response;
+    });
+}
+export function validateItems(items, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield post("/alpaca/headless/editor/validate", items.map(getItemDescriptor), sessionId);
+        if (response.type !== "success")
+            return response;
+        return yield response;
+    });
+}
+export function executeWorkflowCommand(item, commandId, comment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch("/alpaca/headless/editor/executeWorkflowCommand", {
+            method: "POST",
+            body: JSON.stringify({ item, commandId, comment }),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.status === 500 || response.redirected) {
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while locking the item.",
+                response,
+            };
+        }
+        if (response.status === 401) {
+            return {
+                type: "error",
+                summary: "Unauthorized",
+                details: "Not logged in anymore?",
+                response,
+            };
+        }
+        return { type: "success", response };
+    });
+}
+export function executeFieldAction(item, fieldId, pageItem, action, sessionId, selectedText, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch("/alpaca/headless/editor/executeFieldAction?sessionId=" + sessionId, {
+            method: "POST",
+            body: JSON.stringify({
+                item,
+                pageItem,
+                fieldId,
+                action,
+                selectedText,
+                sessionId,
+            }),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.status === 500 || response.redirected) {
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while locking the item.",
+                response,
+            };
+        }
+        if (response.status === 401) {
+            return {
+                type: "error",
+                summary: "Unauthorized",
+                details: "Not logged in anymore?",
+                response,
+            };
+        }
+        if (!(response === null || response === void 0 ? void 0 : response.body))
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured.",
+                response,
+            };
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let result = null;
+        while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true }); // 'stream: true' ensures that any incomplete multi-byte characters aren't malformed.
+            // Split the buffer by newline and keep the last partial line for the next iteration.
+            const lines = buffer.split("\n");
+            if (lines.length > 0) {
+                buffer = lines.pop() || ""; // Incomplete line (if any) is kept for the next iteration.
+                for (let line of lines) {
+                    if (line.trim() === "")
+                        continue; // Skip empty lines if any.
+                    try {
+                        const jsonData = JSON.parse(line);
+                        callback(jsonData);
+                        result = jsonData;
+                    }
+                    catch (e) {
+                        console.error("Error parsing line:" + line, e);
+                    }
+                }
+            }
+        }
+        // If there's any remaining content in the buffer after processing all chunks, try to process it.
+        if (buffer.trim() !== "") {
+            try {
+                const jsonData = JSON.parse(buffer);
+                result = jsonData;
+            }
+            catch (e) {
+                console.error("Error parsing the final buffer content:", e);
+            }
+        }
+        callback(result);
+        return result;
+    });
+}
+export function createVersion(page, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch("/alpaca/headless/editor/createVersion?sessionId=" + sessionId, {
+            method: "POST",
+            body: JSON.stringify({
+                item: page,
+            }),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.ok)
+            return { type: "success", response };
+        else {
+            if (response.status === 401) {
+                return {
+                    type: "error",
+                    summary: "Unauthorized",
+                    details: "Not logged in anymore?",
+                    response,
+                };
+            }
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while saving changes.",
+                response,
+            };
+        }
+    });
+}
+export function loadFallbackChain(field) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/fallbackchain";
+        const response = yield post(url, field);
+        return yield response.response.json();
+    });
+}
+export function loadInsertOptions(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/insertoptions";
+        const response = yield fetch(url, {
+            method: "POST",
+            credentials: "include",
+            body: JSON.stringify(item),
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        return yield response.json();
+    });
+}
+export function loadDropLinkOptions(field, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/getdroplinkoptions";
+        const fieldItem = field._editor.descriptor.item;
+        const response = yield post(url, { item: fieldItem, fieldId: field.id }, sessionId);
+        return yield response.response.json();
+    });
+}
+export function createItem(parent, templateId, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/createItem";
+        const response = yield fetch(url, {
+            method: "POST",
+            credentials: "include",
+            body: JSON.stringify({
+                parent,
+                templateId,
+                name,
+            }),
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.ok)
+            return { type: "success", response };
+        else {
+            if (response.status === 401) {
+                return {
+                    type: "error",
+                    summary: "Unauthorized",
+                    details: "Not logged in anymore?",
+                    response,
+                };
+            }
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while saving changes.",
+                response,
+            };
+        }
+    });
+}
+export function getEditHistory(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = "/alpaca/headless/editor/editHistory?itemId=" +
+            item.id +
+            "&language=" +
+            item.language +
+            "&version=" +
+            item.version;
+        const response = yield fetch(url, {
+            method: "GET",
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        const data = (yield response.json());
+        return data;
+    });
+}

package/dist/esm/editor/services/serviceHelper.js

@@ -0,0 +1,45 @@
+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 Cookies from "universal-cookie";
+export function post(url, body, session) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (session)
+            url += "?sessionId=" + session;
+        const response = yield fetch(url, {
+            method: "POST",
+            body: JSON.stringify(body),
+            credentials: "include",
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: new Cookies().getAll(),
+            },
+            next: {
+                revalidate: 0,
+            },
+        });
+        if (response.status === 500 || response.redirected) {
+            return {
+                type: "error",
+                summary: "Error",
+                details: "An error occured while locking the item.",
+                response,
+            };
+        }
+        if (response.status === 401) {
+            return {
+                type: "error",
+                summary: "Unauthorized",
+                details: "Not logged in anymore?",
+                response,
+            };
+        }
+        return { type: "success", response };
+    });
+}

package/dist/esm/editor/sidebar/ComponentPalette.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEditContext } from "../editContext";
+import { getInsertOptionsForCurrentSelection } from "../utils/insertOptions";
+import { ArrowDownIcon } from "../ui/Icons";
+export function ComponentPalette({}) {
+    const editContext = useEditContext();
+    if (!editContext)
+        return;
+    const currentInsertOptions = getInsertOptionsForCurrentSelection(editContext);
+    const insertOptionsByGroup = currentInsertOptions.reduce((acc, value) => {
+        const group = value.group || "Other";
+        if (!acc[group]) {
+            acc[group] = [];
+        }
+        acc[group].push(value);
+        return acc;
+    }, {});
+    return (_jsx("div", { children: Object.keys(insertOptionsByGroup)
+            .sort()
+            .map((group) => {
+            const options = insertOptionsByGroup[group];
+            return (_jsxs("div", { className: "a-m-4 a-py-4 a-border-t a-border-gray-200", children: [_jsxs("div", { className: "a-text-xs a-font-bold a-mb-3 a-flex a-items-center a-gap-2", children: [_jsx(ArrowDownIcon, {}), " ", group] }), _jsx("div", { className: "a-grid a-gap-4 a-grid-cols-[repeat(auto-fill,_minmax(70px,_1fr))]", children: options
+                            .filter((x) => !x.isHidden)
+                            .map((option) => {
+                            function handleDragStart(event) {
+                                editContext === null || editContext === void 0 ? void 0 : editContext.dragStart({
+                                    type: "template",
+                                    templateId: option.id,
+                                    name: option.name,
+                                });
+                                event.stopPropagation();
+                            }
+                            function handleDragEnd() {
+                                editContext.dragEnd();
+                                editContext.setSelectedForInsertion("");
+                            }
+                            const isDraggable = option.isComponent;
+                            return (_jsxs("div", { draggable: isDraggable, onDragStart: handleDragStart, onDragEnd: handleDragEnd, className: "a-p-2 a-border a-border-gray-200 a-flex a-items-center a-flex-col a-gap-2 a-text-center a-text-xs a-relative a-rounded " +
+                                    (isDraggable ? "a-cursor-grab" : ""), children: [option.svg && (_jsx("div", { className: "a-w-8 a-h-8", dangerouslySetInnerHTML: { __html: option.svg } })), !option.svg && (_jsx("img", { src: option.icon, width: "32", height: "32" })), option.name, !option.isComponent && (_jsx("i", { className: "pi pi-exclamation-triangle a-text-red-500 a-absolute  a-top-0 a-right-0", title: "Template does not inherit Headless ContentPart template." }))] }, option.id));
+                        }) })] }, group));
+        }) }));
+}