@alpaca-editor/core 1.0.3762-mono

package/dist/editor/services/aiService.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAiProfiles = loadAiProfiles;
+exports.executePrompt = executePrompt;
+exports.executeSearch = executeSearch;
+const serviceHelper_1 = require("./serviceHelper");
+async function loadAiProfiles(item) {
+    let url = "/alpaca/editor/ai/profiles";
+    const response = await (0, serviceHelper_1.post)(url, item);
+    if (response.type !== "success") {
+        throw new Error("Error loading AI profiles");
+    }
+    return response.data || [];
+}
+async function executePrompt(messages, editContext, createAiContext, allowedFunctions, addContextContent, options, model, callback) {
+    const context = createAiContext({ editContext });
+    const response = await fetch(context.endpoint, {
+        method: "POST",
+        body: JSON.stringify({
+            messages,
+            ...context.promptData,
+            selection: editContext.selection,
+            sessionId: editContext.sessionId,
+            allowedFunctions,
+            addContextContent,
+            model,
+        }),
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        ...options,
+    });
+    if (!response?.body)
+        return null;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let result = null;
+    while (true) {
+        const { done, value } = await 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);
+        }
+    }
+    return result;
+}
+async function executeSearch({ query, editContext, maxResults = 10, index, rootItemIds, skipValidation = false, }) {
+    const response = await fetch("/alpaca/editor/ai/search", {
+        method: "POST",
+        body: JSON.stringify({
+            contextItem: {
+                id: editContext.currentItemDescriptor?.id,
+                language: "en",
+                version: 0,
+            },
+            query,
+            index,
+            maxResults,
+            rootItemIds,
+            skipValidation,
+        }),
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok)
+        return { type: "error", response };
+    return { type: "success", response, data: await response.json() };
+}

package/dist/editor/services/componentDesignerService.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNewComponent = createNewComponent;
+exports.createRendering = createRendering;
+exports.getAllComponents = getAllComponents;
+exports.getFieldTypes = getFieldTypes;
+exports.loadComponentDetails = loadComponentDetails;
+exports.saveComponentDetails = saveComponentDetails;
+const utils_1 = require("../utils");
+const serviceHelper_1 = require("./serviceHelper");
+async function createNewComponent(name, contextItem) {
+    let url = "/alpaca/headless/component/create";
+    const response = await (0, serviceHelper_1.post)(url, {
+        name,
+        contextItem: (0, utils_1.getItemDescriptor)(contextItem),
+    });
+    if (!response.response.ok) {
+        return new Error("Error creating new component");
+    }
+    return await response.response.json();
+}
+async function createRendering(name, context, componentTemplateId) {
+    let url = "/alpaca/headless/component/createRendering";
+    const response = await (0, serviceHelper_1.post)(url, {
+        contextItem: (0, utils_1.getItemDescriptor)(context),
+        componentTemplateId,
+        name,
+    });
+    if (!response.response.ok) {
+        return new Error("Error creating new rendering");
+    }
+    return await response.response.json();
+}
+async function getAllComponents(contextItemId) {
+    let url = "/alpaca/headless/component/all?contextItemId=" + contextItemId;
+    const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    return await response.json();
+}
+async function getFieldTypes() {
+    let url = "/alpaca/headless/component/fieldtypes";
+    const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    return await response.json();
+}
+async function loadComponentDetails(id, contextItemId) {
+    let url = "/alpaca/headless/component?id=" + id + "&contextItemId=" + contextItemId;
+    const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    return await response.json();
+}
+async function saveComponentDetails(component, contextItem) {
+    let url = "/alpaca/headless/component/save";
+    const response = await (0, serviceHelper_1.post)(url, {
+        component,
+        contextItem: (0, utils_1.getItemDescriptor)(contextItem),
+    });
+    if (response.response.ok) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}

package/dist/editor/services/contentService.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChildren = getChildren;
+exports.fetchItems = fetchItems;
+exports.getSites = getSites;
+exports.resolvePageAndSite = resolvePageAndSite;
+exports.getLanguagesAndVersions = getLanguagesAndVersions;
+exports.getPageJson = getPageJson;
+exports.getDictionary = getDictionary;
+exports.getWorkbox = getWorkbox;
+const universal_cookie_1 = __importDefault(require("universal-cookie"));
+const serviceHelper_1 = require("./serviceHelper");
+async function getChildren(itemId, sessionId, templateIds = [], includeEmbeddedItems, language, include) {
+    let url = 
+    // configuration.services.editorService.baseUrl +
+    "/alpaca/editor/children?itemId=" +
+        itemId +
+        "&sessionId=" +
+        sessionId +
+        "&includeEmbeddedItems=" +
+        includeEmbeddedItems +
+        "&language=" +
+        language +
+        "&include=" +
+        include;
+    url = templateIds.reduce((u, t) => u + "&templateIds=" + t, url);
+    const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    return await response.json();
+}
+// export async function getItem(
+//   item: ItemDescriptor
+// ): Promise<FullItem | undefined> {
+//   let url =
+//     "/alpaca/editor/item?itemId=" +
+//     item.id +
+//     "&language=" +
+//     item.language +
+//     "&version=" +
+//     item.version;
+//   const response = await fetch(url, {
+//     method: "GET",
+//     credentials: "include",
+//     headers: {
+//       "Content-Type": "application/json",
+//       Cookie: new Cookies().getAll(),
+//     },
+//   });
+//   if (response.ok) {
+//     const json = await response.json();
+//     return json;
+//   }
+//   return undefined;
+// }
+async function fetchItems(itemDescriptors) {
+    let url = "/alpaca/editor/items";
+    const response = await (0, serviceHelper_1.post)(url, itemDescriptors);
+    return response.data || [];
+}
+async function getSites() {
+    return await (0, serviceHelper_1.get)("/alpaca/editor/sites");
+}
+async function resolvePageAndSite(itemId, language, version) {
+    const result = await (0, serviceHelper_1.post)("/alpaca/editor/resolve", {
+        itemId,
+        language,
+        version,
+        mode: "edit",
+    });
+    if (result.data) {
+        return result.data;
+    }
+}
+async function getLanguagesAndVersions(item) {
+    return await (0, serviceHelper_1.post)("/alpaca/editor/getLanguagesAndVersions", item);
+}
+async function getPageJson(page) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/headless/layout", {
+        itemId: page.id,
+        language: page.language,
+        version: page.version,
+        mode: "preview",
+    });
+    return response.data?.page;
+}
+async function getDictionary(siteName, language) {
+    let response = await (0, serviceHelper_1.get)("/alpaca/editor/dictionary/index?siteName=" +
+        siteName +
+        "&language=" +
+        language);
+    return response.data;
+}
+async function getWorkbox(items) {
+    return await (0, serviceHelper_1.post)("/alpaca/editor/workbox", items);
+}

package/dist/editor/services/editService.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectSocket = connectSocket;
+exports.getPictureValue = getPictureValue;
+exports.executeEditOperation = executeEditOperation;
+exports.executeUndo = executeUndo;
+exports.executeRedo = executeRedo;
+exports.executeDeleteItems = executeDeleteItems;
+exports.lockItems = lockItems;
+exports.unlockItems = unlockItems;
+exports.lockField = lockField;
+exports.releaseFieldLocks = releaseFieldLocks;
+exports.validateItems = validateItems;
+exports.executeWorkflowCommand = executeWorkflowCommand;
+exports.executeFieldAction = executeFieldAction;
+exports.createVersion = createVersion;
+exports.deleteVersion = deleteVersion;
+exports.loadInsertOptions = loadInsertOptions;
+exports.loadPlaceholderInsertOptions = loadPlaceholderInsertOptions;
+exports.loadFieldButtons = loadFieldButtons;
+exports.getLookupSources = getLookupSources;
+exports.executeCreateItem = executeCreateItem;
+exports.getEditHistory = getEditHistory;
+exports.getFieldHistory = getFieldHistory;
+exports.getUserInfo = getUserInfo;
+exports.executeMoveItems = executeMoveItems;
+const universal_cookie_1 = __importDefault(require("universal-cookie"));
+const serviceHelper_1 = require("./serviceHelper");
+function connectSocket(sessionId) {
+    const host = window.location.hostname;
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const port = window.location.port ? `:${window.location.port}` : "";
+    const socketUrl = `${protocol}//${host}${port}/alpaca/editor/socket?sessionId=${sessionId}`;
+    console.log("Connect to socket: " + socketUrl);
+    return new WebSocket(socketUrl);
+}
+async function getPictureValue(field, pictureRawValue, site, sessionId) {
+    const fieldItem = field.descriptor.item;
+    if (!fieldItem)
+        return;
+    const response = await fetch("/alpaca/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 universal_cookie_1.default().getAll(),
+        },
+    });
+    return await response.json();
+}
+async function executeEditOperation(editOperation, sessionId) {
+    editOperation.sessionId = sessionId;
+    return (0, serviceHelper_1.post)("/alpaca/editor/edit", editOperation, sessionId);
+}
+async function executeUndo(sessionId, editOperationIds) {
+    return (0, serviceHelper_1.post)("/alpaca/editor/undo", { editOperationIds }, sessionId);
+}
+async function executeRedo(sessionId, editOperationId) {
+    return (0, serviceHelper_1.post)("/alpaca/editor/redo", { editOperationIds: [editOperationId] }, sessionId);
+}
+async function executeDeleteItems(items) {
+    return (0, serviceHelper_1.post)("/alpaca/editor/deleteItems", items);
+}
+function getItemDescriptor(item) {
+    return {
+        id: item.id,
+        language: item.language,
+        version: item.version,
+    };
+}
+async function lockItems(items) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/lock", items.map(getItemDescriptor));
+    return response;
+}
+async function unlockItems(items) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/unlock", items.map(getItemDescriptor));
+    return response;
+}
+async function lockField(item, fieldId, sessionId) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/lockField", {
+        item,
+        fieldId: fieldId,
+        sessionId: sessionId,
+    });
+    return response;
+}
+async function releaseFieldLocks(sessionId) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/releaseFieldLocks", {
+        sessionId,
+    });
+    return response;
+}
+async function validateItems(items, sessionId) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/validate", items.map(getItemDescriptor), sessionId);
+    if (response.type !== "success")
+        return response;
+    return await response;
+}
+async function executeWorkflowCommand(item, commandId, comment) {
+    const response = await (0, serviceHelper_1.post)("/alpaca/editor/executeWorkflowCommand", {
+        item,
+        commandId,
+        comment,
+    });
+    return response;
+}
+async function executeFieldAction(item, fieldId, pageItem, action, sessionId, selectedText, callback) {
+    const response = await fetch("/alpaca/editor/executeFieldAction?sessionId=" + sessionId, {
+        method: "POST",
+        body: JSON.stringify({
+            item,
+            pageItem,
+            fieldId,
+            action,
+            selectedText,
+            sessionId,
+        }),
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    if (response.status === 500 || response.redirected) {
+        return {
+            type: "error",
+            summary: "Error",
+            details: "An error occured executing the field action.",
+            response,
+        };
+    }
+    if (response.status === 401) {
+        return {
+            type: "error",
+            summary: "Unauthorized",
+            details: "Not logged in anymore?",
+            response,
+        };
+    }
+    if (!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 } = await 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;
+}
+async function createVersion(page, sessionId) {
+    const response = await fetch(
+    // configuration.services.editorService.baseUrl +
+    "/alpaca/editor/createVersion?sessionId=" + sessionId, {
+        method: "POST",
+        body: JSON.stringify({
+            item: page,
+        }),
+        credentials: "include",
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    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,
+        };
+    }
+}
+async function deleteVersion(page, sessionId) {
+    const url = "/alpaca/editor/deleteVersion?sessionId=" + sessionId;
+    return await (0, serviceHelper_1.post)(url, { item: getItemDescriptor(page) });
+}
+async function loadInsertOptions(item) {
+    let url = 
+    //configuration.services.editorService.baseUrl +
+    "/alpaca/editor/insertoptions";
+    const response = await fetch(url, {
+        method: "POST",
+        credentials: "include",
+        body: JSON.stringify(item),
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    return await response.json();
+}
+async function loadPlaceholderInsertOptions(pageItem, placeholderKeys) {
+    let url = "/alpaca/editor/placeholderinsertoptions";
+    const response = await fetch(url, {
+        method: "POST",
+        credentials: "include",
+        body: JSON.stringify({ pageItem, placeholderKeys }),
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    return await response.json();
+}
+async function loadFieldButtons(field) {
+    let url = 
+    //configuration.services.editorService.baseUrl +
+    "/alpaca/editor/fieldbuttons";
+    const response = await fetch(url, {
+        method: "POST",
+        credentials: "include",
+        body: JSON.stringify(field),
+        headers: {
+            "Content-Type": "application/json",
+            Cookie: new universal_cookie_1.default().getAll(),
+        },
+    });
+    return await response.json();
+}
+async function getLookupSources(field, sessionId) {
+    let url = "/alpaca/editor/getlookupsources";
+    const fieldItem = field.descriptor.item;
+    const response = await (0, serviceHelper_1.post)(url, { item: fieldItem, fieldId: field.id }, sessionId);
+    return (await response.data) || [];
+}
+async function executeCreateItem(parent, templateId, name) {
+    let url = "/alpaca/editor/createItem";
+    const resopnse = (0, serviceHelper_1.post)(url, { parent, templateId, name });
+    return resopnse;
+}
+async function getEditHistory(item) {
+    let url = "/alpaca/editor/editHistory?itemId=" +
+        item.id +
+        "&language=" +
+        item.language +
+        "&version=" +
+        item.version;
+    const result = (0, serviceHelper_1.get)(url);
+    return result;
+}
+async function getFieldHistory(item, fieldId) {
+    let url = "/alpaca/editor/fieldHistory?itemId=" +
+        item.id +
+        "&language=" +
+        item.language +
+        "&version=" +
+        item.version +
+        "&fieldId=" +
+        fieldId;
+    const result = (0, serviceHelper_1.get)(url);
+    return result;
+}
+async function getUserInfo() {
+    const response = await fetch("/alpaca/editor/userinfo");
+    return await response.json();
+}
+async function executeMoveItems(items, target, index) {
+    return (0, serviceHelper_1.post)("/alpaca/editor/moveItems", {
+        items: items.map(getItemDescriptor),
+        target: getItemDescriptor(target),
+        index,
+    });
+}

package/dist/editor/services/indexService.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndexStatus = getIndexStatus;
+exports.setupIndex = setupIndex;
+exports.setupRebuildJob = setupRebuildJob;
+exports.rebuildIndex = rebuildIndex;
+exports.getIndexes = getIndexes;
+const serviceHelper_1 = require("./serviceHelper");
+async function getIndexStatus(index) {
+    var result = await (0, serviceHelper_1.get)("/alpaca/headless/editor/index/status?name=" + index);
+    return result.data;
+}
+async function setupIndex(index) {
+    await (0, serviceHelper_1.post)("/alpaca/headless/editor/index/setup?name=" + index, {});
+}
+async function setupRebuildJob(index) {
+    await (0, serviceHelper_1.post)("/alpaca/headless/editor/index/setuprebuildjob?name=" + index, {});
+}
+async function rebuildIndex(index) {
+    await (0, serviceHelper_1.post)("/alpaca/headless/editor/index/rebuild?name=" + index, {});
+}
+async function getIndexes() {
+    var result = await (0, serviceHelper_1.get)("/alpaca/headless/editor/index/list");
+    return result.data || [];
+}

package/dist/editor/services/reviewsService.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrUpdateComment = createOrUpdateComment;
+exports.getComments = getComments;
+exports.resolveComment = resolveComment;
+exports.deleteComment = deleteComment;
+exports.getReviewers = getReviewers;
+exports.getReviews = getReviews;
+exports.inviteReviewer = inviteReviewer;
+exports.addReview = addReview;
+exports.approveReview = approveReview;
+exports.rejectReview = rejectReview;
+const serviceHelper_1 = require("./serviceHelper");
+function createOrUpdateComment(comment) {
+    return (0, serviceHelper_1.post)("/alpaca/editor/comments/save", comment);
+}
+function getComments(itemId, language, version) {
+    return (0, serviceHelper_1.get)(`/alpaca/editor/comments/index?mainItemId=${itemId}&language=${language}&version=${version}`);
+}
+function resolveComment(comment) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/comments/resolve?commentId=${comment.id}`, {});
+}
+function deleteComment(comment) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/comments/delete?commentId=${comment.id}`, {});
+}
+function getReviewers(itemId, language) {
+    return (0, serviceHelper_1.get)(`/alpaca/editor/reviews/reviewers?itemId=${itemId}&language=${language}`);
+}
+function getReviews(itemId, language, version) {
+    return (0, serviceHelper_1.get)(`/alpaca/editor/reviews/index?itemId=${itemId}&language=${language}&version=${version}`);
+}
+function inviteReviewer(review) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/reviews/invite`, review);
+}
+function addReview(review) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/reviews/add`, review);
+}
+function approveReview(itemDescriptor) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/reviews/approve`, itemDescriptor);
+}
+function rejectReview(itemDescriptor) {
+    return (0, serviceHelper_1.post)(`/alpaca/editor/reviews/reject`, itemDescriptor);
+}