@alpaca-editor/core 1.0.3762-mono

package/dist/editor/client/GenericDialog.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericDialog = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const dialog_1 = require("primereact/dialog");
+const react_1 = require("react");
+exports.GenericDialog = (0, react_1.forwardRef)((_, ref) => {
+    const [content, setContent] = (0, react_1.useState)(null);
+    const [title, setTitle] = (0, react_1.useState)("");
+    const [width, setWidth] = (0, react_1.useState)("50vw");
+    const [height, setHeight] = (0, react_1.useState)("50vh");
+    const [visible, setVisible] = (0, react_1.useState)(false);
+    const show = (props) => {
+        setTitle(props.title);
+        setContent(props.content);
+        if (props.width)
+            setWidth(props.width);
+        if (props.height)
+            setHeight(props.height);
+        setVisible(true);
+    };
+    (0, react_1.useImperativeHandle)(ref, () => ({
+        show,
+        hide: () => setVisible(false),
+    }));
+    return ((0, jsx_runtime_1.jsx)(dialog_1.Dialog, { onHide: () => setVisible(false), visible: visible, header: title, style: { width, height }, children: content }));
+});

package/dist/editor/client/editContext.js

@@ -0,0 +1,59 @@
+"use client";
+"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.OperationsContextProvider = exports.useOperationsContext = exports.ModifiedFieldsContextProvider = exports.useModifiedFieldsContext = exports.useEditContext = exports.EditContextProvider = void 0;
+exports.useEditContextRef = useEditContextRef;
+const react_1 = __importStar(require("react"));
+const EditContext = react_1.default.createContext(undefined);
+exports.EditContextProvider = EditContext.Provider;
+const useEditContext = () => (0, react_1.useContext)(EditContext);
+exports.useEditContext = useEditContext;
+function useEditContextRef() {
+    const contextValue = (0, exports.useEditContext)();
+    const contextRef = (0, react_1.useRef)(contextValue);
+    (0, react_1.useEffect)(() => {
+        contextRef.current = contextValue;
+    }, [contextValue]);
+    return contextRef;
+}
+const ModifiedFieldsContext = react_1.default.createContext(undefined);
+const useModifiedFieldsContext = () => (0, react_1.useContext)(ModifiedFieldsContext);
+exports.useModifiedFieldsContext = useModifiedFieldsContext;
+exports.ModifiedFieldsContextProvider = ModifiedFieldsContext.Provider;
+const OperationsContext = react_1.default.createContext(undefined);
+const useOperationsContext = () => (0, react_1.useContext)(OperationsContext);
+exports.useOperationsContext = useOperationsContext;
+exports.OperationsContextProvider = OperationsContext.Provider;

package/dist/editor/client/helpers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrorResult = handleErrorResult;
+function handleErrorResult(result, ui, state) {
+    if (result.type === "error") {
+        console.log("show error toast", result);
+        ui.showErrorToast({
+            summary: result.summary || "Error",
+            details: result.details || "An error occurred",
+        });
+        return true;
+    }
+    if (result.type === "unauthorized") {
+        if (state.configuration.events.onUnauthorized) {
+            state.configuration.events.onUnauthorized();
+            return true;
+        }
+        ui.confirmationDialogRef.current?.confirm({
+            header: "Not logged in",
+            message: "You are not logged in anymore. Proceed to login page?",
+            accept: () => {
+                window.location.href = "/sitecore/login";
+            },
+        });
+        ui.showErrorToast({
+            summary: result.summary || "Error",
+            details: result.details || "An error occurred",
+        });
+        return true;
+    }
+}

package/dist/editor/client/itemsRepository.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useItemsRepository = useItemsRepository;
+const react_1 = require("react");
+const contentService_1 = require("../services/contentService");
+const utils_1 = require("../utils");
+function useItemsRepository(setModifiedFields, setLastEditedFields) {
+    const itemsMap = (0, react_1.useRef)(new Map());
+    const fallbackDependencyMap = (0, react_1.useRef)(new Map());
+    const pendingRequests = (0, react_1.useRef)(new Map());
+    const [revision, setRevision] = (0, react_1.useState)(0);
+    const itemsChangedListeners = (0, react_1.useRef)(new Set());
+    const fetchItemsFromServer = (0, react_1.useCallback)(async (itemsToLoad) => {
+        // Group items by their keys to deduplicate requests
+        const requestGroups = new Map();
+        itemsToLoad.forEach((item) => {
+            const key = generateKey(item);
+            if (!requestGroups.has(key)) {
+                requestGroups.set(key, item);
+            }
+        });
+        // Create a single promise for all non-pending items
+        const itemsToFetch = Array.from(requestGroups.entries())
+            .filter(([key]) => !pendingRequests.current.has(key))
+            .map(([_, item]) => item);
+        if (itemsToFetch.length === 0) {
+            // Wait for all pending requests to complete
+            await Promise.all(Array.from(pendingRequests.current.values()));
+            return;
+        }
+        const fetchPromise = (async () => {
+            const fetchedItems = await (0, contentService_1.fetchItems)(itemsToFetch);
+            if (!fetchedItems)
+                return;
+            fetchedItems.forEach((item, index) => {
+                if (!item)
+                    return;
+                const descriptor = (0, utils_1.getItemDescriptor)(item);
+                const itemToStore = {
+                    ...item,
+                    descriptor,
+                };
+                itemsMap.current.set(generateKey(item), itemToStore);
+                if (itemsToFetch[index]?.version === 0) {
+                    const key = generateKey(itemsToFetch[index]);
+                    itemsMap.current.set(key, itemToStore);
+                }
+                if (item.fields) {
+                    item.fields.forEach((field) => {
+                        if (field.fallbackChain) {
+                            const descriptor = (0, utils_1.getItemDescriptor)(item);
+                            field.fallbackChain.forEach((fallback) => {
+                                const prev = fallbackDependencyMap.current.get(getItemIdLanguageKey(fallback.item));
+                                if (!prev?.find((x) => x.id === descriptor.id &&
+                                    x.language === descriptor.language &&
+                                    x.version === descriptor.version)) {
+                                    fallbackDependencyMap.current.set(getItemIdLanguageKey(fallback.item), [...(prev || []), descriptor]);
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        })();
+        // Store the promise for each item being fetched
+        itemsToFetch.forEach((item) => {
+            const key = generateKey(item);
+            pendingRequests.current.set(key, fetchPromise);
+        });
+        try {
+            await fetchPromise;
+        }
+        finally {
+            // Clean up pending requests
+            itemsToFetch.forEach((item) => {
+                pendingRequests.current.delete(generateKey(item));
+            });
+        }
+    }, [itemsMap.current]);
+    const getItems = (0, react_1.useCallback)(async (descriptors) => {
+        const keys = descriptors.map((x) => ({
+            key: generateKey(x),
+            descriptor: x,
+        }));
+        const itemsMissing = keys.filter((item) => !itemsMap.current.has(item.key));
+        const map = itemsMap;
+        if (itemsMissing.length > 0) {
+            await fetchItemsFromServer(itemsMissing.map((x) => x.descriptor));
+        }
+        return descriptors
+            .map((x) => map.current.get(generateKey(x)))
+            .filter((x) => x !== undefined);
+    }, [itemsMap.current, fetchItemsFromServer]);
+    const getField = (0, react_1.useCallback)(async (fieldDescriptor) => {
+        const item = await getItem(fieldDescriptor.item);
+        return item?.fields.find((x) => x.id === fieldDescriptor.fieldId);
+    }, [itemsMap.current]);
+    const getItem = (0, react_1.useCallback)(async (descriptor) => {
+        const items = await getItems([descriptor]);
+        return items[0];
+    }, [getItems]);
+    const updateFieldValue = (0, react_1.useCallback)(async (field, user, isDirty, value, rawValue) => {
+        const item = await getItem(field.item);
+        if (!item)
+            return;
+        const fieldToUpdate = item.fields.find((x) => x.id === field.fieldId);
+        if (!fieldToUpdate)
+            return;
+        itemsMap.current.set(generateKey(field.item), { ...item });
+        setModifiedFields((prevModifiedFields) => {
+            const val = rawValue !== undefined ? rawValue : value;
+            const modifiedField = prevModifiedFields.find((x) => x.fieldId === field.fieldId &&
+                x.item.id === field.item.id &&
+                x.item.language === field.item.language &&
+                x.item.version === field.item.version);
+            if (!modifiedField) {
+                return [
+                    ...prevModifiedFields,
+                    {
+                        ...field,
+                        value: val,
+                        isDirty: isDirty,
+                        modifiedBy: user,
+                        timestamp: Date.now(),
+                    },
+                ];
+            }
+            else {
+                modifiedField.isDirty = isDirty;
+                modifiedField.value = val;
+                modifiedField.modifiedBy = user;
+                modifiedField.timestamp = Date.now();
+            }
+            return [...prevModifiedFields];
+        });
+        setLastEditedFields((prevEditedFields) => {
+            return [
+                ...prevEditedFields.filter((x) => x.timestamp > Date.now() - 30000 &&
+                    (x.fieldId !== field.fieldId ||
+                        x.item.id !== field.item.id ||
+                        x.item.language !== field.item.language ||
+                        x.item.version !== field.item.version)),
+                { ...field, timestamp: Date.now(), user },
+            ];
+        });
+        //      setRevision((prev) => prev + 1);
+    }, [itemsMap, fetchItemsFromServer]);
+    const refreshItems = (0, react_1.useCallback)(async (items) => {
+        const itemsToFetch = [...items];
+        items.forEach((item) => {
+            if (itemsMap.current.has(generateKey({ ...item, version: 0 }))) {
+                itemsToFetch.push({ ...item, version: 0 });
+            }
+        });
+        const time = Date.now();
+        await fetchItemsFromServer(itemsToFetch);
+        const getFieldValue = (ItemDescriptor, fieldId) => {
+            const item = itemsMap.current.get(generateKey(ItemDescriptor));
+            if (!item)
+                return null;
+            const field = item.fields?.find((f) => f.id === fieldId);
+            if (!field)
+                return null;
+            return field.rawValue ?? null;
+        };
+        const updateModifiedFields = (prevModifiedFields) => {
+            return prevModifiedFields.map((x) => {
+                if (itemsToFetch.find((y) => y.id === x.item.id &&
+                    y.language === x.item.language &&
+                    y.version === x.item.version) &&
+                    isOutdated(x))
+                    return { ...x, value: getFieldValue(x.item, x.fieldId) };
+                return x;
+            });
+        };
+        const isOutdated = (x) => {
+            if (x.timestamp > time)
+                return false;
+            const item = itemsMap.current.get(generateKey(x.item));
+            if (!item)
+                return true;
+            const field = item.fields?.find((f) => f.id === x.fieldId);
+            if (!field)
+                return true;
+            return field.rawValue !== x.value;
+        };
+        setModifiedFields(updateModifiedFields);
+        triggerItemsChangedEvent(items.map((x) => ({ item: x, action: "update" })));
+        setRevision((prev) => prev + 1);
+    }, [setRevision]);
+    const onFieldSaved = (0, react_1.useCallback)((field, value) => {
+        setModifiedFields((prevModifiedFields) => {
+            const modifiedField = prevModifiedFields.find((x) => x.fieldId === field.fieldId &&
+                x.item.id === field.item.id &&
+                x.item.language === field.item.language &&
+                x.item.version === field.item.version);
+            if (modifiedField) {
+                if (modifiedField.value === value)
+                    modifiedField.isDirty = false;
+                return [...prevModifiedFields];
+            }
+            return prevModifiedFields;
+        });
+        const dependencies = fallbackDependencyMap.current.get(getItemIdLanguageKey(field.item));
+        if (dependencies) {
+            refreshItems(dependencies);
+        }
+        triggerItemsChangedEvent([{ item: field.item, action: "update" }]);
+    }, [setModifiedFields]);
+    const onItemsDeleted = (0, react_1.useCallback)((items) => {
+        items.forEach((item) => {
+            itemsMap.current.delete(generateKey(item.item));
+        });
+        triggerItemsChangedEvent(items.map((x) => ({
+            item: x.item,
+            action: "delete",
+            parentId: x.parentId,
+        })));
+        setRevision((prev) => prev + 1);
+    }, [itemsMap, setRevision]);
+    const subscribeItemsChanged = (0, react_1.useCallback)((callback) => {
+        itemsChangedListeners.current.add(callback);
+        // Return an unsubscribe function
+        return () => {
+            itemsChangedListeners.current.delete(callback);
+        };
+    }, []);
+    const triggerItemsChangedEvent = (changes) => {
+        const listeners = itemsChangedListeners.current;
+        if (listeners) {
+            listeners.forEach((callback) => callback(changes));
+        }
+    };
+    const repo = (0, react_1.useMemo)(() => {
+        return {
+            getItems,
+            getItem,
+            getField,
+            updateFieldValue,
+            //     addToModifiedFields,
+            refreshItems,
+            revision,
+            onFieldSaved,
+            onItemsDeleted,
+            subscribeItemsChanged,
+        };
+    }, [getItems, getItem, getField, revision, updateFieldValue, onItemsDeleted]);
+    return repo;
+}
+function generateKey(descriptor) {
+    return `${descriptor.id}-${descriptor.language}-${descriptor.version}`.toLowerCase();
+}
+function getItemIdLanguageKey(descriptor) {
+    return `${descriptor.id}${descriptor.language}`.toLowerCase();
+}