@dextinity/cms-admin 2.0.0-canary-20260729062014

package/lib/pages/pageTree/PageTreeService.d.ts

@@ -0,0 +1,43 @@
+import type { DropTarget } from "./PageTreeRow";
+import type { PageTreePage } from "./usePageTree";
+interface PageTreeUpdateInfo {
+    parentId: string | null;
+    position: number;
+    neighbourPage: PageTreePage;
+}
+interface PageTreeUndoUpdateInfo {
+    afterId: string | null;
+    beforeId: string | null;
+}
+export interface DropInfo {
+    dropTarget: DropTarget;
+    targetLevel: number;
+}
+interface NeighbouringLevel {
+    level1?: number;
+    level2?: number;
+}
+interface PageTreeNodePosition {
+    pos?: number;
+    parent: string | null;
+    level: number;
+}
+export declare class PageTreeService {
+    readonly levelOffsetPx: number;
+    private readonly pages;
+    constructor(levelOffsetPx: number, pages: PageTreePage[]);
+    calculateTargetLevel(mouseX: number, itemX: number, { level1, level2 }: NeighbouringLevel): number;
+    calculateDropTarget(mouseY: number, dropTargetElementRect: DOMRect): DropTarget;
+    dropAllowed(draggedPages: PageTreePage[], dropTargetPage: PageTreePage, dropTarget: DropTarget, targetLevel: number): PageTreeUpdateInfo | false;
+    getPageTreeNodeUpdateInfo(targetLevel: number, dropTargetPage: PageTreePage, dropTarget: DropTarget): PageTreeUpdateInfo | null;
+    calcInsertInBetweenPosition(node?: PageTreePage, nextNode?: PageTreePage): PageTreeNodePosition;
+    getUndoUpdateInfo(allPagesBeforeMove: PageTreePage[], pageBeforeMove: PageTreePage, disallowedReferencePages: PageTreePage[]): PageTreeUndoUpdateInfo;
+    private getAddAsChildUpdateInfo;
+    private getAddBeforeOrAfterUpdateInfo;
+    private findNeighbourUpwards;
+    private findNeighbourDownwards;
+    private findNeighbour;
+    private getUpdateInfoFromNeighbourPage;
+}
+export {};
+//# sourceMappingURL=PageTreeService.d.ts.map

package/lib/pages/pageTree/PageTreeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageTreeService.d.ts","sourceRoot":"","sources":["../../../src/pages/pageTree/PageTreeService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyB,MAAM,eAAe,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,UAAU,kBAAkB;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,YAAY,CAAC;CAC/B;AAED,UAAU,sBAAsB;IAC5B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,iBAAiB;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD,UAAU,oBAAoB;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACjB;AACD,qBAAa,eAAe;IACxB,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;gBAE3B,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE;IAOxD,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,iBAAiB,GAAG,MAAM;IAoBlG,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,qBAAqB,EAAE,OAAO,GAAG,UAAU;IAmC/E,WAAW,CAAC,YAAY,EAAE,YAAY,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB,GAAG,KAAK;IA6BhJ,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,GAAG,kBAAkB,GAAG,IAAI;IAU/H,2BAA2B,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,oBAAoB;IAiF/F,iBAAiB,CACb,kBAAkB,EAAE,YAAY,EAAE,EAClC,cAAc,EAAE,YAAY,EAC5B,wBAAwB,EAAE,YAAY,EAAE,GACzC,sBAAsB;IA6DzB,OAAO,CAAC,uBAAuB;IAW/B,OAAO,CAAC,6BAA6B;IAmDrC,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,aAAa;IAoBrB,OAAO,CAAC,8BAA8B;CAczC"}

package/lib/pages/pageTree/PageTreeService.js

@@ -0,0 +1,388 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// interface that describes a position of a node within the tree
+
+export var PageTreeService = /*#__PURE__*/function () {
+  function PageTreeService(levelOffsetPx, pages) {
+    _classCallCheck(this, PageTreeService);
+    _defineProperty(this, "levelOffsetPx", void 0);
+    _defineProperty(this, "pages", void 0);
+    this.levelOffsetPx = levelOffsetPx;
+    this.pages = pages;
+  }
+
+  // Calculates the targetLevel from the mouse position in relation to the x coordinate of the target item
+  // Maximum and minimum level are defined by { level1, level2 } (order does not matter)
+  return _createClass(PageTreeService, [{
+    key: "calculateTargetLevel",
+    value: function calculateTargetLevel(mouseX, itemX, _ref) {
+      var level1 = _ref.level1,
+        level2 = _ref.level2;
+      // levels are only undefined when the current divider is before the first or after the last item
+      // in the PageTree. Then you should always be able to add to level 0
+      var neighbouringLevels = [level1 !== null && level1 !== void 0 ? level1 : 0, level2 !== null && level2 !== void 0 ? level2 : 0];
+      var minLevel = Math.min.apply(Math, neighbouringLevels);
+      var maxLevel = Math.max.apply(Math, neighbouringLevels);
+      var offsetBetweenDropTargetAndMouse = mouseX - itemX;
+      var hypotheticalLevel = Math.floor(offsetBetweenDropTargetAndMouse / this.levelOffsetPx);
+      if (hypotheticalLevel < minLevel) {
+        return minLevel;
+      } else if (hypotheticalLevel > maxLevel) {
+        return maxLevel;
+      } else {
+        return hypotheticalLevel;
+      }
+    }
+  }, {
+    key: "calculateDropTarget",
+    value: function calculateDropTarget(mouseY, dropTargetElementRect) {
+      // min is inclusive
+      // max is exclusive
+      // Item is split into three parts:
+      var dropTargetBoundaries = {
+        // Drop on first quarter (0/4 - 1/4) of item height => add before current item
+        ADD_BEFORE: {
+          // - 5 => a bit of margin for the divider
+          min: dropTargetElementRect.y - 5,
+          max: dropTargetElementRect.y + dropTargetElementRect.height / 4
+        },
+        // Drop between first quarter and last quarter (1/4 - 3/4) of item height => add as child of current item
+        ADD_AS_CHILD: {
+          min: dropTargetElementRect.y + dropTargetElementRect.height / 4,
+          max: dropTargetElementRect.y + dropTargetElementRect.height / 4 * 3
+        },
+        // Drop on last quarter (3/4 - 4/4)  of item height => add after current item
+        ADD_AFTER: {
+          min: dropTargetElementRect.y + dropTargetElementRect.height / 4 * 3,
+          // + 5 => a bit of margin for the divider
+          max: dropTargetElementRect.bottom + 5
+        }
+      };
+      if (mouseY >= dropTargetBoundaries["ADD_BEFORE"].min && mouseY < dropTargetBoundaries["ADD_BEFORE"].max) {
+        return "ADD_BEFORE";
+      } else if (mouseY >= dropTargetBoundaries["ADD_AFTER"].min && mouseY < dropTargetBoundaries["ADD_AFTER"].max) {
+        return "ADD_AFTER";
+      } else {
+        return "ADD_AS_CHILD";
+      }
+    }
+
+    // Returns an IPageTreeUpdateInfo object if drop is possible.
+    // Otherwise returns false
+  }, {
+    key: "dropAllowed",
+    value: function dropAllowed(draggedPages, dropTargetPage, dropTarget, targetLevel) {
+      var updateInfo = this.getPageTreeNodeUpdateInfo(targetLevel, dropTargetPage, dropTarget);
+      var _iterator = _createForOfIteratorHelper(draggedPages),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var draggedPage = _step.value;
+          if (draggedPage.slug === "home" && dropTarget === "ADD_AS_CHILD") {
+            return false;
+          }
+          if (!updateInfo ||
+          // No fitting parent exists
+          updateInfo.parentId === draggedPage.id ||
+          // Item cannot be its own parent
+          updateInfo.neighbourPage.ancestorIds.includes(draggedPage.id) // Item cannot be its own subitem
+          ) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (updateInfo === null) {
+        return false;
+      }
+      return updateInfo;
+    }
+
+    // Searches a new neighbour for an item based on the dropTargetPage, targetLevel and dropTarget.
+    // Generates an IPageTreeUpdateInfo object based on information from this neighbour.
+    // Returns an IPageTreeUpdateInfo object containing all information needed for an update if a suiting
+    // neighbour is found.
+    // Returns null if no suiting neighbour is found.
+  }, {
+    key: "getPageTreeNodeUpdateInfo",
+    value: function getPageTreeNodeUpdateInfo(targetLevel, dropTargetPage, dropTarget) {
+      if (dropTarget === "ADD_AS_CHILD") {
+        return this.getAddAsChildUpdateInfo(dropTargetPage);
+      }
+      return this.getAddBeforeOrAfterUpdateInfo(dropTargetPage, targetLevel, dropTarget);
+    }
+    // given a node and it's next node
+    // this function calculates the position of the node that will be inserted in between
+    // in some cases 2 positions are possible, than we apply "choose highest level"-strategy
+  }, {
+    key: "calcInsertInBetweenPosition",
+    value: function calcInsertInBetweenPosition(node, nextNode) {
+      // edge case: there is no previous node
+      // in this case the insert in between position is the very first one
+      if (node == null) {
+        return {
+          parent: null,
+          pos: 0,
+          level: 0
+        };
+      }
+      // edge case: nextNode is the first position of the next deeper level
+      // in this case the inBetweenNode is added at pos 0 and the same level as nextNode
+      //
+      //
+      //
+      //   before:
+      //   - node
+      //   - - nextNode
+      //
+      //  after:
+      //  - node
+      //  - - inBetweenNode
+      //  - - nextNOde
+
+      if (nextNode && node.level < nextNode.level) {
+        return {
+          pos: 0,
+          parent: node.id,
+          level: nextNode.level
+        };
+      }
+
+      // edge case: nextNode is the first position of the next higher level
+      // in this case the inBetweenNode is
+      // added at pos of node + 1 and the same level as node (A)
+      // or
+      // added at pos of nextNode -1 and the same level as nextNode (B)
+      //
+      // we implement version A (choose-highest-level)
+      //
+      //   A:
+      //
+      //   before:
+      //   - - node
+      //   - nextNode
+      //
+      //  after:
+      //  - - node
+      //  - - inBetweenNode
+      //  - nextNode
+      //
+      if (nextNode && node.level > nextNode.level) {
+        return {
+          pos: node.pos + 1,
+          parent: node.parentId,
+          level: node.level
+        };
+      }
+      // edge case: node is last node at all, and it's level is not 0
+      if (!nextNode && node.level > 0) {
+        return {
+          pos: node.pos + 1,
+          parent: node.parentId,
+          level: node.level
+        };
+      }
+      //  standard case: node and NextNode are on the same level
+      //  or no nextNode at all
+      //
+      //   before:
+      //   - node
+      //   - nextNode
+      //
+      //  after:
+      //  - node
+      //  - inBetweenNode
+      //  - nextNOde
+
+      return {
+        pos: node.pos + 1,
+        parent: node.parentId,
+        level: node.level
+      };
+    }
+  }, {
+    key: "getUndoUpdateInfo",
+    value: function getUndoUpdateInfo(allPagesBeforeMove, pageBeforeMove, disallowedReferencePages) {
+      var _afterPage$id, _afterPage2, _beforePage$id, _beforePage2;
+      // disallowedReferencePages are pages that haven't been moved back to their old position yet.
+      // Therefore, they cannot be used as a reference point for moving other pages.
+      //
+      // Example:
+      //
+      // Starting Point:
+      // - node-1
+      // - - node-1-1
+      // - - node-1-2
+      // - node-2
+      //
+      // Then you move node-1-1 and node-1-2 to the root:
+      // - node-1
+      // - node-2
+      // - node-1-1
+      // - node-1-2
+      //
+      // Now you want to undo these changes.
+      // Per default, the algorithm below would make the nodes reference each other:
+      // - node-1-1 should be before node-1-2
+      // - node-1-2 should be after node-1-1
+      //
+      // That doesn't work when actually moving the page because node-1-1 should be located before node-1-2 AND be a child of node-1.
+      // Since node-1-2 at the time of this move isn't a child of node-1, these requirements contradict each other.
+      // => Error
+      //
+      // To avoid this problem, pages that haven't been moved back to their original position should be in disallowedReferencePages.
+      var disallowedReferenceIds = disallowedReferencePages.map(function (page) {
+        return page.id;
+      });
+      var pageIdx = allPagesBeforeMove.findIndex(function (page) {
+        return page.id === pageBeforeMove.id;
+      });
+      var afterPage = null;
+      var beforePage = null;
+      var foundAllowedReference = false;
+      var checkedAllAfterPages = false;
+      do {
+        if (pageIdx - 1 >= 0 && !checkedAllAfterPages) {
+          afterPage = this.findNeighbourUpwards(pageIdx - 1, pageBeforeMove.level, allPagesBeforeMove);
+        }
+        if (pageIdx + 1 < allPagesBeforeMove.length && afterPage === null) {
+          checkedAllAfterPages = true;
+          beforePage = this.findNeighbourDownwards(pageIdx + 1, pageBeforeMove.level, allPagesBeforeMove);
+        }
+        if (afterPage && disallowedReferenceIds.includes(afterPage.id)) {
+          pageIdx = allPagesBeforeMove.findIndex(function (page) {
+            var _afterPage;
+            return page.id === ((_afterPage = afterPage) === null || _afterPage === void 0 ? void 0 : _afterPage.id);
+          });
+        } else if (beforePage && disallowedReferenceIds.includes(beforePage.id)) {
+          pageIdx = allPagesBeforeMove.findIndex(function (page) {
+            var _beforePage;
+            return page.id === ((_beforePage = beforePage) === null || _beforePage === void 0 ? void 0 : _beforePage.id);
+          });
+        } else {
+          foundAllowedReference = true;
+        }
+      } while (!foundAllowedReference);
+      return {
+        afterId: (_afterPage$id = (_afterPage2 = afterPage) === null || _afterPage2 === void 0 ? void 0 : _afterPage2.id) !== null && _afterPage$id !== void 0 ? _afterPage$id : null,
+        beforeId: (_beforePage$id = (_beforePage2 = beforePage) === null || _beforePage2 === void 0 ? void 0 : _beforePage2.id) !== null && _beforePage$id !== void 0 ? _beforePage$id : null
+      };
+    }
+  }, {
+    key: "getAddAsChildUpdateInfo",
+    value: function getAddAsChildUpdateInfo(dropTargetPage) {
+      // Get position of last child of target item => add new item after that (at the end of the sublist)
+      var position = this.pages.reduce(function (maxPosition, page) {
+        if (page.parentId === dropTargetPage.id) {
+          maxPosition = Math.max(maxPosition, page.pos);
+        }
+        return maxPosition;
+      }, 0);
+      return {
+        parentId: dropTargetPage.id,
+        position: position + 1,
+        neighbourPage: dropTargetPage
+      };
+    }
+  }, {
+    key: "getAddBeforeOrAfterUpdateInfo",
+    value: function getAddBeforeOrAfterUpdateInfo(dropTargetPage, targetLevel, dropTarget) {
+      // Check if drop target page is a suitable neighbour
+      if (targetLevel === dropTargetPage.level) {
+        return {
+          parentId: dropTargetPage.parentId,
+          position: dropTarget === "ADD_BEFORE" ? dropTargetPage.pos : dropTargetPage.pos + 1,
+          // else must be ADD_AFTER
+          neighbourPage: dropTargetPage
+        };
+      }
+      var startPageIdx = this.pages.findIndex(function (page) {
+        return page.id === dropTargetPage.id;
+      });
+      var startIdxUpwardSearch = startPageIdx - 1 >= 0 ? startPageIdx - 1 : null;
+      var startIdxDownwardSearch = startPageIdx + 1 < this.pages.length ? startPageIdx + 1 : null;
+      var neighbourPage;
+      var searchDirection;
+      if (dropTarget === "ADD_BEFORE") {
+        // When adding before an item, first search for a neighbour before this item (upwards in the list)
+        searchDirection = "UPWARDS";
+        neighbourPage = this.findNeighbourUpwards(startIdxUpwardSearch, targetLevel, this.pages);
+
+        // If none is found, search for neighbour after this item (downwards in the list)
+        if (!neighbourPage) {
+          searchDirection = "DOWNWARDS";
+          neighbourPage = this.findNeighbourDownwards(startIdxDownwardSearch, targetLevel, this.pages);
+        }
+      } else {
+        // When adding after an item, first search for a neighbour after this item (downwards in the list)
+        searchDirection = "DOWNWARDS";
+        neighbourPage = this.findNeighbourDownwards(startIdxDownwardSearch, targetLevel, this.pages);
+
+        // If none is found, search for neighbour before this item (upwards in the list)
+        if (!neighbourPage) {
+          searchDirection = "UPWARDS";
+          neighbourPage = this.findNeighbourUpwards(startIdxUpwardSearch, targetLevel, this.pages);
+        }
+      }
+      if (!neighbourPage) {
+        return null;
+      }
+      return this.getUpdateInfoFromNeighbourPage(neighbourPage, searchDirection);
+    }
+  }, {
+    key: "findNeighbourUpwards",
+    value: function findNeighbourUpwards(idx, targetLevel, pages) {
+      return this.findNeighbour(idx, targetLevel, function (prevIdx) {
+        return prevIdx - 1 >= 0 ? prevIdx - 1 : null;
+      }, pages);
+    }
+  }, {
+    key: "findNeighbourDownwards",
+    value: function findNeighbourDownwards(idx, targetLevel, pages) {
+      return this.findNeighbour(idx, targetLevel, function (prevIdx) {
+        return prevIdx + 1 < pages.length ? prevIdx + 1 : null;
+      }, pages);
+    }
+  }, {
+    key: "findNeighbour",
+    value: function findNeighbour(idx, targetLevel, calculateNewIdx, pages) {
+      while (idx !== null) {
+        if (pages[idx].level === targetLevel) {
+          return pages[idx];
+        } else if (pages[idx].level < targetLevel) {
+          // Prevent sliding into a different list on the same level
+          idx = null;
+        } else {
+          idx = calculateNewIdx(idx);
+        }
+      }
+      return null;
+    }
+  }, {
+    key: "getUpdateInfoFromNeighbourPage",
+    value: function getUpdateInfoFromNeighbourPage(neighbourPage, searchDirection) {
+      var position;
+      if (searchDirection === "UPWARDS") {
+        position = neighbourPage.pos + 1;
+      } else {
+        position = neighbourPage.pos;
+      }
+      return {
+        parentId: neighbourPage.parentId,
+        position: position,
+        neighbourPage: neighbourPage
+      };
+    }
+  }]);
+}();

package/lib/pages/pageTree/PageTypeIcon.d.ts

@@ -0,0 +1,9 @@
+import type { JSX } from "react";
+import type { PageTreePage } from "./usePageTree";
+interface PageTypeIconProps {
+    page: PageTreePage;
+    disabled?: boolean;
+}
+export declare function PageTypeIcon({ page, disabled }: PageTypeIconProps): JSX.Element;
+export {};
+//# sourceMappingURL=PageTypeIcon.d.ts.map

package/lib/pages/pageTree/PageTypeIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageTypeIcon.d.ts","sourceRoot":"","sources":["../../../src/pages/pageTree/PageTypeIcon.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAa,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,UAAU,iBAAiB;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,iBAAiB,GAAG,GAAG,CAAC,OAAO,CAwB/E"}

package/lib/pages/pageTree/PageTypeIcon.js

@@ -0,0 +1,30 @@
+import { Home, Link as LinkIcon } from "@dextinity/admin-icons";
+import { usePageTreeConfig } from "../pageTreeConfig";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function PageTypeIcon(_ref) {
+  var page = _ref.page,
+    disabled = _ref.disabled;
+  var iconColor = "primary";
+  var _usePageTreeConfig = usePageTreeConfig(),
+    documentTypes = _usePageTreeConfig.documentTypes;
+  var documentType = documentTypes[page.documentType];
+  var Icon;
+  if (page.slug === "home") {
+    Icon = Home;
+  } else if (page.documentType === "Link") {
+    Icon = LinkIcon;
+    iconColor = "inherit";
+  } else {
+    if (page.hideInMenu && documentType.hideInMenuIcon) {
+      Icon = documentType.hideInMenuIcon;
+    } else {
+      Icon = documentType.menuIcon;
+    }
+  }
+  if (page.visibility !== "Published" || disabled) {
+    iconColor = "disabled";
+  }
+  return /*#__PURE__*/_jsx(Icon, {
+    color: iconColor
+  });
+}

package/lib/pages/pageTree/PageVisibility.d.ts

@@ -0,0 +1,8 @@
+import type { PageTreePage } from "./usePageTree";
+export declare const updatePageVisibilityMutation: import("graphql").DocumentNode;
+interface PageVisibilityProps {
+    page: PageTreePage;
+}
+declare const PageVisibility: ({ page }: PageVisibilityProps) => import("react/jsx-runtime").JSX.Element;
+export default PageVisibility;
+//# sourceMappingURL=PageVisibility.d.ts.map

package/lib/pages/pageTree/PageVisibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageVisibility.d.ts","sourceRoot":"","sources":["../../../src/pages/pageTree/PageVisibility.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAA2B,YAAY,EAAE,MAAM,eAAe,CAAC;AAG3E,eAAO,MAAM,4BAA4B,gCASxC,CAAC;AAEF,UAAU,mBAAmB;IACzB,IAAI,EAAE,YAAY,CAAC;CACtB;AAED,QAAA,MAAM,cAAc,GAAI,UAAU,mBAAmB,4CA4GpD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/lib/pages/pageTree/PageVisibility.generated.d.ts

@@ -0,0 +1,21 @@
+import * as Types from '../../graphql.generated';
+export declare const namedOperations: {
+    Mutation: {
+        UpdatePageVisibility: string;
+    };
+};
+export type GQLUpdatePageVisibilityMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.GQLPageTreeNodeUpdateVisibilityInput;
+}>;
+export type GQLUpdatePageVisibilityMutation = {
+    __typename?: 'Mutation';
+    updatePageTreeNodeVisibility: {
+        __typename?: 'PageTreeNode';
+        id: string;
+        visibility: Types.GQLPageTreeNodeVisibility;
+        path: string;
+        slug: string;
+    };
+};
+//# sourceMappingURL=PageVisibility.generated.d.ts.map

package/lib/pages/pageTree/PageVisibility.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageVisibility.generated.d.ts","sourceRoot":"","sources":["../../../src/pages/pageTree/PageVisibility.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,yBAAyB,CAAC;AAEjD,eAAO,MAAM,eAAe;;;;CAI3B,CAAA;AACD,MAAM,MAAM,wCAAwC,GAAG,KAAK,CAAC,KAAK,CAAC;IACjE,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,KAAK,CAAC,oCAAoC,CAAC;CACnD,CAAC,CAAC;AAGH,MAAM,MAAM,+BAA+B,GAAG;IAAE,UAAU,CAAC,EAAE,UAAU,CAAC;IAAC,4BAA4B,EAAE;QAAE,UAAU,CAAC,EAAE,cAAc,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,KAAK,CAAC,yBAAyB,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC"}

package/lib/pages/pageTree/PageVisibility.generated.js

@@ -0,0 +1,5 @@
+export var namedOperations = {
+  Mutation: {
+    UpdatePageVisibility: 'UpdatePageVisibility'
+  }
+};