payload-nested-docs-page-tree 1.1.0

package/dist/utilities/dropTargets.js

@@ -0,0 +1,73 @@
+function getInsertIndex(dropID) {
+    const insertIndex = Number.parseInt(dropID.split(':')[1] ?? '', 10);
+    return Number.isNaN(insertIndex) ? null : insertIndex;
+}
+function getMovingSubtreeIDs(docs, activeDoc) {
+    return new Set(docs.filter((doc)=>doc.__pageTreeID === activeDoc.__pageTreeID || doc.__pageTreeAncestorIDs.includes(activeDoc.__pageTreeID)).map((doc)=>doc.__pageTreeID));
+}
+function getSiblingID(doc) {
+    return doc?.__pageTreeID ?? null;
+}
+export function buildInsertDropTargets(docs) {
+    if (docs.length === 0) {
+        return [];
+    }
+    return Array.from({
+        length: docs.length + 1
+    }, (_, index)=>{
+        const referenceDoc = docs[index] ?? docs[docs.length - 1];
+        return {
+            depth: referenceDoc.__pageTreeDepth,
+            dropID: `page-insert:${index}`,
+            dropType: 'insert',
+            parentID: referenceDoc.__pageTreeParentID,
+            referenceRowID: referenceDoc.__pageTreeID
+        };
+    });
+}
+export function getDropTargetParentDoc(args) {
+    const { docsByID, dropTarget } = args;
+    if (!dropTarget) {
+        return null;
+    }
+    if (dropTarget.dropType === 'row') {
+        return docsByID.get(dropTarget.rowID) ?? null;
+    }
+    if (dropTarget.parentID === null) {
+        return null;
+    }
+    return docsByID.get(dropTarget.parentID) ?? null;
+}
+export function getOrderPlacementFromDropTarget(args) {
+    const { activeDoc, docs, docsByID, dropTarget } = args;
+    if (!dropTarget) {
+        return null;
+    }
+    const movingSubtreeIDs = getMovingSubtreeIDs(docs, activeDoc);
+    if (dropTarget.dropType === 'row') {
+        const targetDoc = docsByID.get(dropTarget.rowID);
+        if (!targetDoc) {
+            return null;
+        }
+        const childSiblings = docs.filter((doc)=>doc.__pageTreeParentID === targetDoc.__pageTreeID && !movingSubtreeIDs.has(doc.__pageTreeID));
+        return {
+            nextSiblingID: null,
+            parentID: targetDoc.__pageTreeID,
+            previousSiblingID: getSiblingID(childSiblings.at(-1))
+        };
+    }
+    const insertIndex = getInsertIndex(dropTarget.dropID);
+    if (insertIndex === null) {
+        return null;
+    }
+    const parentID = dropTarget.parentID;
+    const beforeSiblings = docs.slice(0, insertIndex).filter((doc)=>doc.__pageTreeParentID === parentID && !movingSubtreeIDs.has(doc.__pageTreeID));
+    const afterSiblings = docs.slice(insertIndex).filter((doc)=>doc.__pageTreeParentID === parentID && !movingSubtreeIDs.has(doc.__pageTreeID));
+    return {
+        nextSiblingID: getSiblingID(afterSiblings[0]),
+        parentID,
+        previousSiblingID: getSiblingID(beforeSiblings.at(-1))
+    };
+}
+
+//# sourceMappingURL=dropTargets.js.map

package/dist/utilities/dropTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/dropTargets.ts"],"sourcesContent":["import type { PageTreeDoc } from './pageTree.js'\n\nexport type PageTreeInsertDropTarget = {\n  depth: number\n  dropID: string\n  dropType: 'insert'\n  parentID: null | string\n  referenceRowID: string\n}\n\nexport type PageTreeRowDropTarget = {\n  dropType: 'row'\n  insertAfterDropID: string\n  insertBeforeDropID: string\n  rowID: string\n}\n\nexport type PageTreeDropTarget = PageTreeInsertDropTarget | PageTreeRowDropTarget\n\nexport type PageTreeOrderPlacement = {\n  nextSiblingID: null | string\n  parentID: null | string\n  previousSiblingID: null | string\n}\n\nfunction getInsertIndex(dropID: string): null | number {\n  const insertIndex = Number.parseInt(dropID.split(':')[1] ?? '', 10)\n\n  return Number.isNaN(insertIndex) ? null : insertIndex\n}\n\nfunction getMovingSubtreeIDs(docs: PageTreeDoc[], activeDoc: PageTreeDoc): Set<string> {\n  return new Set(\n    docs\n      .filter(\n        (doc) =>\n          doc.__pageTreeID === activeDoc.__pageTreeID ||\n          doc.__pageTreeAncestorIDs.includes(activeDoc.__pageTreeID),\n      )\n      .map((doc) => doc.__pageTreeID),\n  )\n}\n\nfunction getSiblingID(doc: PageTreeDoc | undefined): null | string {\n  return doc?.__pageTreeID ?? null\n}\n\nexport function buildInsertDropTargets(docs: PageTreeDoc[]): PageTreeInsertDropTarget[] {\n  if (docs.length === 0) {\n    return []\n  }\n\n  return Array.from({ length: docs.length + 1 }, (_, index) => {\n    const referenceDoc = docs[index] ?? docs[docs.length - 1]\n\n    return {\n      depth: referenceDoc.__pageTreeDepth,\n      dropID: `page-insert:${index}`,\n      dropType: 'insert',\n      parentID: referenceDoc.__pageTreeParentID,\n      referenceRowID: referenceDoc.__pageTreeID,\n    }\n  })\n}\n\nexport function getDropTargetParentDoc(args: {\n  docsByID: ReadonlyMap<string, PageTreeDoc>\n  dropTarget: null | PageTreeDropTarget\n}): null | PageTreeDoc {\n  const { docsByID, dropTarget } = args\n\n  if (!dropTarget) {\n    return null\n  }\n\n  if (dropTarget.dropType === 'row') {\n    return docsByID.get(dropTarget.rowID) ?? null\n  }\n\n  if (dropTarget.parentID === null) {\n    return null\n  }\n\n  return docsByID.get(dropTarget.parentID) ?? null\n}\n\nexport function getOrderPlacementFromDropTarget(args: {\n  activeDoc: PageTreeDoc\n  docs: PageTreeDoc[]\n  docsByID: ReadonlyMap<string, PageTreeDoc>\n  dropTarget: null | PageTreeDropTarget\n}): null | PageTreeOrderPlacement {\n  const { activeDoc, docs, docsByID, dropTarget } = args\n\n  if (!dropTarget) {\n    return null\n  }\n\n  const movingSubtreeIDs = getMovingSubtreeIDs(docs, activeDoc)\n\n  if (dropTarget.dropType === 'row') {\n    const targetDoc = docsByID.get(dropTarget.rowID)\n\n    if (!targetDoc) {\n      return null\n    }\n\n    const childSiblings = docs.filter(\n      (doc) =>\n        doc.__pageTreeParentID === targetDoc.__pageTreeID &&\n        !movingSubtreeIDs.has(doc.__pageTreeID),\n    )\n\n    return {\n      nextSiblingID: null,\n      parentID: targetDoc.__pageTreeID,\n      previousSiblingID: getSiblingID(childSiblings.at(-1)),\n    }\n  }\n\n  const insertIndex = getInsertIndex(dropTarget.dropID)\n\n  if (insertIndex === null) {\n    return null\n  }\n\n  const parentID = dropTarget.parentID\n  const beforeSiblings = docs\n    .slice(0, insertIndex)\n    .filter((doc) => doc.__pageTreeParentID === parentID && !movingSubtreeIDs.has(doc.__pageTreeID))\n  const afterSiblings = docs\n    .slice(insertIndex)\n    .filter((doc) => doc.__pageTreeParentID === parentID && !movingSubtreeIDs.has(doc.__pageTreeID))\n\n  return {\n    nextSiblingID: getSiblingID(afterSiblings[0]),\n    parentID,\n    previousSiblingID: getSiblingID(beforeSiblings.at(-1)),\n  }\n}\n"],"names":["getInsertIndex","dropID","insertIndex","Number","parseInt","split","isNaN","getMovingSubtreeIDs","docs","activeDoc","Set","filter","doc","__pageTreeID","__pageTreeAncestorIDs","includes","map","getSiblingID","buildInsertDropTargets","length","Array","from","_","index","referenceDoc","depth","__pageTreeDepth","dropType","parentID","__pageTreeParentID","referenceRowID","getDropTargetParentDoc","args","docsByID","dropTarget","get","rowID","getOrderPlacementFromDropTarget","movingSubtreeIDs","targetDoc","childSiblings","has","nextSiblingID","previousSiblingID","at","beforeSiblings","slice","afterSiblings"],"mappings":"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"}

package/dist/utilities/moveValidation.d.ts

@@ -0,0 +1,11 @@
+import type { PageTreeDoc } from './pageTree.js';
+export declare const CANCEL_DRAG_MESSAGE = "Release to cancel drag.";
+export type PageTreeDropValidation = {
+    isValid: boolean;
+    message?: string;
+    parentID: null | string;
+};
+export declare function getDropValidation(args: {
+    activeDoc: PageTreeDoc;
+    targetDoc?: PageTreeDoc;
+}): PageTreeDropValidation;

package/dist/utilities/moveValidation.js

@@ -0,0 +1,44 @@
+export const CANCEL_DRAG_MESSAGE = 'Release to cancel drag.';
+export function getDropValidation(args) {
+    const { activeDoc, targetDoc } = args;
+    if (!targetDoc) {
+        if (activeDoc.__pageTreeParentID === null) {
+            return {
+                isValid: false,
+                message: 'Document is already at the root.',
+                parentID: null
+            };
+        }
+        return {
+            isValid: true,
+            parentID: null
+        };
+    }
+    if (targetDoc.__pageTreeID === activeDoc.__pageTreeID) {
+        return {
+            isValid: false,
+            message: CANCEL_DRAG_MESSAGE,
+            parentID: targetDoc.__pageTreeID
+        };
+    }
+    if (targetDoc.__pageTreeAncestorIDs.includes(activeDoc.__pageTreeID)) {
+        return {
+            isValid: false,
+            message: 'A document cannot be moved under one of its descendants.',
+            parentID: targetDoc.__pageTreeID
+        };
+    }
+    if (activeDoc.__pageTreeParentID === targetDoc.__pageTreeID) {
+        return {
+            isValid: false,
+            message: 'Document already has that parent.',
+            parentID: targetDoc.__pageTreeID
+        };
+    }
+    return {
+        isValid: true,
+        parentID: targetDoc.__pageTreeID
+    };
+}
+
+//# sourceMappingURL=moveValidation.js.map

package/dist/utilities/moveValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/moveValidation.ts"],"sourcesContent":["import type { PageTreeDoc } from './pageTree.js'\r\n\r\nexport const CANCEL_DRAG_MESSAGE = 'Release to cancel drag.'\r\n\r\nexport type PageTreeDropValidation = {\r\n  isValid: boolean\r\n  message?: string\r\n  parentID: null | string\r\n}\r\n\r\nexport function getDropValidation(args: {\r\n  activeDoc: PageTreeDoc\r\n  targetDoc?: PageTreeDoc\r\n}): PageTreeDropValidation {\r\n  const { activeDoc, targetDoc } = args\r\n\r\n  if (!targetDoc) {\r\n    if (activeDoc.__pageTreeParentID === null) {\r\n      return {\r\n        isValid: false,\r\n        message: 'Document is already at the root.',\r\n        parentID: null,\r\n      }\r\n    }\r\n\r\n    return {\r\n      isValid: true,\r\n      parentID: null,\r\n    }\r\n  }\r\n\r\n  if (targetDoc.__pageTreeID === activeDoc.__pageTreeID) {\r\n    return {\r\n      isValid: false,\r\n      message: CANCEL_DRAG_MESSAGE,\r\n      parentID: targetDoc.__pageTreeID,\r\n    }\r\n  }\r\n\r\n  if (targetDoc.__pageTreeAncestorIDs.includes(activeDoc.__pageTreeID)) {\r\n    return {\r\n      isValid: false,\r\n      message: 'A document cannot be moved under one of its descendants.',\r\n      parentID: targetDoc.__pageTreeID,\r\n    }\r\n  }\r\n\r\n  if (activeDoc.__pageTreeParentID === targetDoc.__pageTreeID) {\r\n    return {\r\n      isValid: false,\r\n      message: 'Document already has that parent.',\r\n      parentID: targetDoc.__pageTreeID,\r\n    }\r\n  }\r\n\r\n  return {\r\n    isValid: true,\r\n    parentID: targetDoc.__pageTreeID,\r\n  }\r\n}\r\n"],"names":["CANCEL_DRAG_MESSAGE","getDropValidation","args","activeDoc","targetDoc","__pageTreeParentID","isValid","message","parentID","__pageTreeID","__pageTreeAncestorIDs","includes"],"mappings":"AAEA,OAAO,MAAMA,sBAAsB,0BAAyB;AAQ5D,OAAO,SAASC,kBAAkBC,IAGjC;IACC,MAAM,EAAEC,SAAS,EAAEC,SAAS,EAAE,GAAGF;IAEjC,IAAI,CAACE,WAAW;QACd,IAAID,UAAUE,kBAAkB,KAAK,MAAM;YACzC,OAAO;gBACLC,SAAS;gBACTC,SAAS;gBACTC,UAAU;YACZ;QACF;QAEA,OAAO;YACLF,SAAS;YACTE,UAAU;QACZ;IACF;IAEA,IAAIJ,UAAUK,YAAY,KAAKN,UAAUM,YAAY,EAAE;QACrD,OAAO;YACLH,SAAS;YACTC,SAASP;YACTQ,UAAUJ,UAAUK,YAAY;QAClC;IACF;IAEA,IAAIL,UAAUM,qBAAqB,CAACC,QAAQ,CAACR,UAAUM,YAAY,GAAG;QACpE,OAAO;YACLH,SAAS;YACTC,SAAS;YACTC,UAAUJ,UAAUK,YAAY;QAClC;IACF;IAEA,IAAIN,UAAUE,kBAAkB,KAAKD,UAAUK,YAAY,EAAE;QAC3D,OAAO;YACLH,SAAS;YACTC,SAAS;YACTC,UAAUJ,UAAUK,YAAY;QAClC;IACF;IAEA,OAAO;QACLH,SAAS;QACTE,UAAUJ,UAAUK,YAAY;IAClC;AACF"}

package/dist/utilities/pageTree.d.ts

@@ -0,0 +1,37 @@
+import type { PageTreeSourceDoc } from '../types.js';
+export type { PageTreeSourceDoc } from '../types.js';
+export type PageTreeMeta = {
+    __pageTreeAncestorIDs: string[];
+    __pageTreeDepth: number;
+    __pageTreeHasChildren: boolean;
+    __pageTreeID: string;
+    __pageTreeOrderIndex: number;
+    __pageTreeParentID: null | string;
+    __pageTreeShadeLevel: number;
+};
+export type PageTreeDoc = PageTreeMeta & PageTreeSourceDoc;
+export type BuildPageTreeDocsOptions = {
+    parentFieldSlug?: string;
+    sort?: string;
+};
+export declare function stringifyDocID(id: number | string | undefined): string;
+export declare function getRelationshipID(value: unknown): null | string;
+export declare function getDocParentID(doc: PageTreeSourceDoc, parentFieldSlug?: string): null | string;
+export declare function getDocDisplayLabel(doc: PageTreeDoc): string;
+export declare function getDocSlugSegment(doc: PageTreeDoc): string;
+export declare function buildDocSlugPath(args: {
+    doc: PageTreeDoc;
+    docsByID: Map<string, PageTreeDoc>;
+}): string;
+export declare function buildProspectiveDocSlugPath(args: {
+    activeDoc: PageTreeDoc;
+    docsByID: Map<string, PageTreeDoc>;
+    targetDoc?: PageTreeDoc;
+}): string;
+export declare function buildChildrenByParentID(args: {
+    docs: PageTreeSourceDoc[];
+    parentFieldSlug?: string;
+}): Map<null | string, string[]>;
+export declare function collectDescendantIDs(rootID: string, childrenByParentID: Map<null | string, string[]>): string[];
+export declare function buildPageTreeDocs(docs: PageTreeSourceDoc[], options?: BuildPageTreeDocsOptions): PageTreeDoc[];
+export declare function getVisibleTreeDocs(docs: PageTreeDoc[], collapsedIDs: ReadonlySet<string>): PageTreeDoc[];

package/dist/utilities/pageTree.js

@@ -0,0 +1,300 @@
+const dateLikePattern = /^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$/;
+export function stringifyDocID(id) {
+    return String(id ?? '');
+}
+export function getRelationshipID(value) {
+    if (typeof value === 'number' || typeof value === 'string') {
+        return stringifyDocID(value);
+    }
+    if (value && typeof value === 'object' && 'id' in value) {
+        const relationshipID = value.id;
+        if (typeof relationshipID === 'number' || typeof relationshipID === 'string') {
+            return stringifyDocID(relationshipID);
+        }
+    }
+    return null;
+}
+export function getDocParentID(doc, parentFieldSlug = 'parent') {
+    return getRelationshipID(doc[parentFieldSlug]);
+}
+export function getDocDisplayLabel(doc) {
+    const title = doc.title;
+    if (typeof title === 'string' && title.trim().length > 0) {
+        return title;
+    }
+    if (typeof doc.slug === 'string' && doc.slug.trim().length > 0) {
+        return doc.slug;
+    }
+    return doc.__pageTreeID;
+}
+export function getDocSlugSegment(doc) {
+    if (typeof doc.slug === 'string' && doc.slug.trim().length > 0) {
+        return doc.slug.trim().replace(/^\/+|\/+$/g, '');
+    }
+    return doc.__pageTreeID;
+}
+export function buildDocSlugPath(args) {
+    const { doc, docsByID } = args;
+    const segments = doc.__pageTreeAncestorIDs.map((ancestorID)=>docsByID.get(ancestorID)).filter((ancestorDoc)=>Boolean(ancestorDoc)).map(getDocSlugSegment);
+    segments.push(getDocSlugSegment(doc));
+    return `/${segments.filter(Boolean).join('/')}`;
+}
+export function buildProspectiveDocSlugPath(args) {
+    const { activeDoc, docsByID, targetDoc } = args;
+    if (!targetDoc) {
+        return `/${getDocSlugSegment(activeDoc)}`;
+    }
+    const segments = targetDoc.__pageTreeAncestorIDs.map((ancestorID)=>docsByID.get(ancestorID)).filter((ancestorDoc)=>Boolean(ancestorDoc)).map(getDocSlugSegment);
+    segments.push(getDocSlugSegment(targetDoc), getDocSlugSegment(activeDoc));
+    return `/${segments.filter(Boolean).join('/')}`;
+}
+export function buildChildrenByParentID(args) {
+    const { docs, parentFieldSlug = 'parent' } = args;
+    const childrenByParentID = new Map();
+    for (const doc of docs){
+        const docID = stringifyDocID(doc.id);
+        const parentID = getDocParentID(doc, parentFieldSlug);
+        const existingChildren = childrenByParentID.get(parentID) ?? [];
+        existingChildren.push(docID);
+        childrenByParentID.set(parentID, existingChildren);
+    }
+    return childrenByParentID;
+}
+export function collectDescendantIDs(rootID, childrenByParentID) {
+    const descendantIDs = [];
+    const stack = [
+        ...childrenByParentID.get(rootID) ?? []
+    ];
+    while(stack.length > 0){
+        const currentID = stack.pop();
+        if (!currentID) {
+            continue;
+        }
+        descendantIDs.push(currentID);
+        stack.push(...childrenByParentID.get(currentID) ?? []);
+    }
+    return descendantIDs;
+}
+function getCycleNodeIDs(nodes, nodesByID) {
+    const cycleNodeIDs = new Set();
+    const pathStack = [];
+    const visitState = new Map();
+    const walk = (node)=>{
+        const currentState = visitState.get(node.id);
+        if (currentState === 'done') {
+            return;
+        }
+        if (currentState === 'visiting') {
+            const cycleStartIndex = pathStack.lastIndexOf(node.id);
+            const cycleIDs = cycleStartIndex >= 0 ? pathStack.slice(cycleStartIndex) : [
+                node.id
+            ];
+            for (const cycleID of cycleIDs){
+                cycleNodeIDs.add(cycleID);
+            }
+            return;
+        }
+        visitState.set(node.id, 'visiting');
+        pathStack.push(node.id);
+        if (node.parentID !== null) {
+            const parentNode = nodesByID.get(node.parentID);
+            if (parentNode) {
+                walk(parentNode);
+            }
+        }
+        pathStack.pop();
+        visitState.set(node.id, 'done');
+    };
+    for (const node of nodes){
+        walk(node);
+    }
+    return cycleNodeIDs;
+}
+function parseSortTokens(sort) {
+    if (typeof sort !== 'string' || sort.trim().length === 0) {
+        return [];
+    }
+    return sort.split(',').map((token)=>token.trim()).filter((token)=>token.length > 0).map((token)=>{
+        const descending = token.startsWith('-');
+        const normalizedToken = descending ? token.slice(1) : token;
+        return {
+            descending,
+            path: normalizedToken.split('.').filter(Boolean)
+        };
+    }).filter((token)=>token.path.length > 0);
+}
+function resolveSortValue(source, path) {
+    let currentValue = source;
+    for (const segment of path){
+        if (!currentValue || typeof currentValue !== 'object' || Array.isArray(currentValue)) {
+            return undefined;
+        }
+        if (!(segment in currentValue)) {
+            return undefined;
+        }
+        currentValue = currentValue[segment];
+    }
+    if (currentValue === null || currentValue === undefined) {
+        return null;
+    }
+    if (currentValue instanceof Date) {
+        const timestamp = currentValue.getTime();
+        return Number.isNaN(timestamp) ? undefined : timestamp;
+    }
+    if (typeof currentValue === 'boolean') {
+        return currentValue ? 1 : 0;
+    }
+    if (typeof currentValue === 'number') {
+        return Number.isFinite(currentValue) ? currentValue : undefined;
+    }
+    if (typeof currentValue !== 'string') {
+        return undefined;
+    }
+    const normalizedValue = currentValue.trim();
+    if (dateLikePattern.test(normalizedValue)) {
+        const timestamp = Date.parse(normalizedValue);
+        if (!Number.isNaN(timestamp)) {
+            return timestamp;
+        }
+    }
+    return normalizedValue;
+}
+function compareSortValues(leftValue, rightValue) {
+    if (leftValue === null && rightValue === null) {
+        return 0;
+    }
+    if (leftValue === null) {
+        return -1;
+    }
+    if (rightValue === null) {
+        return 1;
+    }
+    if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+        if (leftValue === rightValue) {
+            return 0;
+        }
+        return leftValue < rightValue ? -1 : 1;
+    }
+    return String(leftValue).localeCompare(String(rightValue), undefined, {
+        numeric: true,
+        sensitivity: 'base'
+    });
+}
+function createTreeNodeComparator(sort) {
+    const sortTokens = parseSortTokens(sort);
+    if (sortTokens.length === 0) {
+        return null;
+    }
+    return (leftNode, rightNode)=>{
+        for (const sortToken of sortTokens){
+            const leftValue = resolveSortValue(leftNode.doc, sortToken.path);
+            const rightValue = resolveSortValue(rightNode.doc, sortToken.path);
+            if (leftValue === undefined || rightValue === undefined) {
+                continue;
+            }
+            const comparison = compareSortValues(leftValue, rightValue);
+            if (comparison !== 0) {
+                return sortToken.descending ? -comparison : comparison;
+            }
+        }
+        return leftNode.originalIndex - rightNode.originalIndex;
+    };
+}
+export function buildPageTreeDocs(docs, options = {}) {
+    const parentFieldSlug = options.parentFieldSlug ?? 'parent';
+    const nodes = docs.map((doc, index)=>({
+            doc,
+            id: stringifyDocID(doc.id),
+            originalIndex: index,
+            parentID: getDocParentID(doc, parentFieldSlug)
+        }));
+    const nodesByID = new Map(nodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    const cycleNodeIDs = getCycleNodeIDs(nodes, nodesByID);
+    const effectiveParentIDByNodeID = new Map();
+    const childrenByParentID = new Map();
+    const compareTreeNodes = createTreeNodeComparator(options.sort);
+    for (const node of nodes){
+        const parentExists = node.parentID !== null && nodesByID.has(node.parentID);
+        const effectiveParentID = parentExists && !cycleNodeIDs.has(node.id) ? node.parentID : null;
+        effectiveParentIDByNodeID.set(node.id, effectiveParentID);
+        const currentChildren = childrenByParentID.get(effectiveParentID) ?? [];
+        currentChildren.push(node);
+        childrenByParentID.set(effectiveParentID, currentChildren);
+    }
+    if (compareTreeNodes) {
+        for (const children of childrenByParentID.values()){
+            children.sort(compareTreeNodes);
+        }
+    }
+    const orderedDocs = [];
+    const subtreeDepthByID = new Map();
+    const visitedNodeIDs = new Set();
+    const getShadeLevel = (rootMaxDepth, depth)=>{
+        if (rootMaxDepth === 0) {
+            return 0;
+        }
+        return Math.max(rootMaxDepth - depth + 1, 1);
+    };
+    const getSubtreeDepth = (node)=>{
+        const cachedDepth = subtreeDepthByID.get(node.id);
+        if (typeof cachedDepth === 'number') {
+            return cachedDepth;
+        }
+        const children = childrenByParentID.get(node.id) ?? [];
+        if (children.length === 0) {
+            subtreeDepthByID.set(node.id, 0);
+            return 0;
+        }
+        const depth = Math.max(...children.map((child)=>getSubtreeDepth(child) + 1));
+        subtreeDepthByID.set(node.id, depth);
+        return depth;
+    };
+    const visit = (node, ancestorIDs, rootMaxDepth)=>{
+        if (visitedNodeIDs.has(node.id)) {
+            return;
+        }
+        visitedNodeIDs.add(node.id);
+        const children = childrenByParentID.get(node.id) ?? [];
+        const depth = ancestorIDs.length;
+        const shadeLevel = getShadeLevel(rootMaxDepth, depth);
+        orderedDocs.push({
+            ...node.doc,
+            __pageTreeAncestorIDs: ancestorIDs,
+            __pageTreeDepth: depth,
+            __pageTreeHasChildren: children.length > 0,
+            __pageTreeID: node.id,
+            __pageTreeOrderIndex: orderedDocs.length,
+            __pageTreeParentID: effectiveParentIDByNodeID.get(node.id) ?? null,
+            __pageTreeShadeLevel: shadeLevel
+        });
+        for (const child of children){
+            visit(child, [
+                ...ancestorIDs,
+                node.id
+            ], rootMaxDepth);
+        }
+    };
+    const roots = [
+        ...childrenByParentID.get(null) ?? []
+    ];
+    for (const root of roots){
+        visit(root, [], getSubtreeDepth(root));
+    }
+    const fallbackNodes = compareTreeNodes ? [
+        ...nodes
+    ].sort(compareTreeNodes) : nodes;
+    for (const node of fallbackNodes){
+        if (!visitedNodeIDs.has(node.id)) {
+            visit(node, [], getSubtreeDepth(node));
+        }
+    }
+    return orderedDocs;
+}
+export function getVisibleTreeDocs(docs, collapsedIDs) {
+    return docs.filter((doc)=>doc.__pageTreeAncestorIDs.every((ancestorID)=>!collapsedIDs.has(ancestorID)));
+}
+
+//# sourceMappingURL=pageTree.js.map

package/dist/utilities/pageTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/pageTree.ts"],"sourcesContent":["import type { PageTreeSourceDoc } from '../types.js'\r\nexport type { PageTreeSourceDoc } from '../types.js'\r\n\r\nexport type PageTreeMeta = {\r\n  __pageTreeAncestorIDs: string[]\r\n  __pageTreeDepth: number\r\n  __pageTreeHasChildren: boolean\r\n  __pageTreeID: string\r\n  __pageTreeOrderIndex: number\r\n  __pageTreeParentID: null | string\r\n  __pageTreeShadeLevel: number\r\n}\r\n\r\nexport type PageTreeDoc = PageTreeMeta & PageTreeSourceDoc\r\n\r\ntype SortToken = {\r\n  descending: boolean\r\n  path: string[]\r\n}\r\n\r\ntype SortValue = null | number | string\r\n\r\ntype TreeNode = {\r\n  doc: PageTreeSourceDoc\r\n  id: string\r\n  originalIndex: number\r\n  parentID: null | string\r\n}\r\n\r\nconst dateLikePattern = /^\\d{4}-\\d{2}-\\d{2}(?:[T\\s].*)?$/\r\n\r\nexport type BuildPageTreeDocsOptions = {\r\n  parentFieldSlug?: string\r\n  sort?: string\r\n}\r\n\r\nexport function stringifyDocID(id: number | string | undefined): string {\r\n  return String(id ?? '')\r\n}\r\n\r\nexport function getRelationshipID(value: unknown): null | string {\r\n  if (typeof value === 'number' || typeof value === 'string') {\r\n    return stringifyDocID(value)\r\n  }\r\n\r\n  if (value && typeof value === 'object' && 'id' in value) {\r\n    const relationshipID = (value as { id?: number | string }).id\r\n\r\n    if (typeof relationshipID === 'number' || typeof relationshipID === 'string') {\r\n      return stringifyDocID(relationshipID)\r\n    }\r\n  }\r\n\r\n  return null\r\n}\r\n\r\nexport function getDocParentID(\r\n  doc: PageTreeSourceDoc,\r\n  parentFieldSlug = 'parent',\r\n): null | string {\r\n  return getRelationshipID(doc[parentFieldSlug])\r\n}\r\n\r\nexport function getDocDisplayLabel(doc: PageTreeDoc): string {\r\n  const title = doc.title\r\n\r\n  if (typeof title === 'string' && title.trim().length > 0) {\r\n    return title\r\n  }\r\n\r\n  if (typeof doc.slug === 'string' && doc.slug.trim().length > 0) {\r\n    return doc.slug\r\n  }\r\n\r\n  return doc.__pageTreeID\r\n}\r\n\r\nexport function getDocSlugSegment(doc: PageTreeDoc): string {\r\n  if (typeof doc.slug === 'string' && doc.slug.trim().length > 0) {\r\n    return doc.slug.trim().replace(/^\\/+|\\/+$/g, '')\r\n  }\r\n\r\n  return doc.__pageTreeID\r\n}\r\n\r\nexport function buildDocSlugPath(args: {\r\n  doc: PageTreeDoc\r\n  docsByID: Map<string, PageTreeDoc>\r\n}): string {\r\n  const { doc, docsByID } = args\r\n  const segments = doc.__pageTreeAncestorIDs\r\n    .map((ancestorID) => docsByID.get(ancestorID))\r\n    .filter((ancestorDoc): ancestorDoc is PageTreeDoc => Boolean(ancestorDoc))\r\n    .map(getDocSlugSegment)\r\n\r\n  segments.push(getDocSlugSegment(doc))\r\n\r\n  return `/${segments.filter(Boolean).join('/')}`\r\n}\r\n\r\nexport function buildProspectiveDocSlugPath(args: {\r\n  activeDoc: PageTreeDoc\r\n  docsByID: Map<string, PageTreeDoc>\r\n  targetDoc?: PageTreeDoc\r\n}): string {\r\n  const { activeDoc, docsByID, targetDoc } = args\r\n\r\n  if (!targetDoc) {\r\n    return `/${getDocSlugSegment(activeDoc)}`\r\n  }\r\n\r\n  const segments = targetDoc.__pageTreeAncestorIDs\r\n    .map((ancestorID) => docsByID.get(ancestorID))\r\n    .filter((ancestorDoc): ancestorDoc is PageTreeDoc => Boolean(ancestorDoc))\r\n    .map(getDocSlugSegment)\r\n\r\n  segments.push(getDocSlugSegment(targetDoc), getDocSlugSegment(activeDoc))\r\n\r\n  return `/${segments.filter(Boolean).join('/')}`\r\n}\r\n\r\nexport function buildChildrenByParentID(args: {\r\n  docs: PageTreeSourceDoc[]\r\n  parentFieldSlug?: string\r\n}): Map<null | string, string[]> {\r\n  const { docs, parentFieldSlug = 'parent' } = args\r\n  const childrenByParentID = new Map<null | string, string[]>()\r\n\r\n  for (const doc of docs) {\r\n    const docID = stringifyDocID(doc.id)\r\n    const parentID = getDocParentID(doc, parentFieldSlug)\r\n    const existingChildren = childrenByParentID.get(parentID) ?? []\r\n\r\n    existingChildren.push(docID)\r\n    childrenByParentID.set(parentID, existingChildren)\r\n  }\r\n\r\n  return childrenByParentID\r\n}\r\n\r\nexport function collectDescendantIDs(\r\n  rootID: string,\r\n  childrenByParentID: Map<null | string, string[]>,\r\n): string[] {\r\n  const descendantIDs: string[] = []\r\n  const stack = [...(childrenByParentID.get(rootID) ?? [])]\r\n\r\n  while (stack.length > 0) {\r\n    const currentID = stack.pop()\r\n\r\n    if (!currentID) {\r\n      continue\r\n    }\r\n\r\n    descendantIDs.push(currentID)\r\n    stack.push(...(childrenByParentID.get(currentID) ?? []))\r\n  }\r\n\r\n  return descendantIDs\r\n}\r\n\r\nfunction getCycleNodeIDs(nodes: TreeNode[], nodesByID: Map<string, TreeNode>): Set<string> {\r\n  const cycleNodeIDs = new Set<string>()\r\n  const pathStack: string[] = []\r\n  const visitState = new Map<string, 'done' | 'visiting'>()\r\n\r\n  const walk = (node: TreeNode) => {\r\n    const currentState = visitState.get(node.id)\r\n\r\n    if (currentState === 'done') {\r\n      return\r\n    }\r\n\r\n    if (currentState === 'visiting') {\r\n      const cycleStartIndex = pathStack.lastIndexOf(node.id)\r\n      const cycleIDs = cycleStartIndex >= 0 ? pathStack.slice(cycleStartIndex) : [node.id]\r\n\r\n      for (const cycleID of cycleIDs) {\r\n        cycleNodeIDs.add(cycleID)\r\n      }\r\n\r\n      return\r\n    }\r\n\r\n    visitState.set(node.id, 'visiting')\r\n    pathStack.push(node.id)\r\n\r\n    if (node.parentID !== null) {\r\n      const parentNode = nodesByID.get(node.parentID)\r\n\r\n      if (parentNode) {\r\n        walk(parentNode)\r\n      }\r\n    }\r\n\r\n    pathStack.pop()\r\n    visitState.set(node.id, 'done')\r\n  }\r\n\r\n  for (const node of nodes) {\r\n    walk(node)\r\n  }\r\n\r\n  return cycleNodeIDs\r\n}\r\n\r\nfunction parseSortTokens(sort?: string): SortToken[] {\r\n  if (typeof sort !== 'string' || sort.trim().length === 0) {\r\n    return []\r\n  }\r\n\r\n  return sort\r\n    .split(',')\r\n    .map((token) => token.trim())\r\n    .filter((token) => token.length > 0)\r\n    .map((token) => {\r\n      const descending = token.startsWith('-')\r\n      const normalizedToken = descending ? token.slice(1) : token\r\n\r\n      return {\r\n        descending,\r\n        path: normalizedToken.split('.').filter(Boolean),\r\n      }\r\n    })\r\n    .filter((token) => token.path.length > 0)\r\n}\r\n\r\nfunction resolveSortValue(source: unknown, path: string[]): SortValue | undefined {\r\n  let currentValue = source\r\n\r\n  for (const segment of path) {\r\n    if (!currentValue || typeof currentValue !== 'object' || Array.isArray(currentValue)) {\r\n      return undefined\r\n    }\r\n\r\n    if (!(segment in currentValue)) {\r\n      return undefined\r\n    }\r\n\r\n    currentValue = (currentValue as Record<string, unknown>)[segment]\r\n  }\r\n\r\n  if (currentValue === null || currentValue === undefined) {\r\n    return null\r\n  }\r\n\r\n  if (currentValue instanceof Date) {\r\n    const timestamp = currentValue.getTime()\r\n\r\n    return Number.isNaN(timestamp) ? undefined : timestamp\r\n  }\r\n\r\n  if (typeof currentValue === 'boolean') {\r\n    return currentValue ? 1 : 0\r\n  }\r\n\r\n  if (typeof currentValue === 'number') {\r\n    return Number.isFinite(currentValue) ? currentValue : undefined\r\n  }\r\n\r\n  if (typeof currentValue !== 'string') {\r\n    return undefined\r\n  }\r\n\r\n  const normalizedValue = currentValue.trim()\r\n\r\n  if (dateLikePattern.test(normalizedValue)) {\r\n    const timestamp = Date.parse(normalizedValue)\r\n\r\n    if (!Number.isNaN(timestamp)) {\r\n      return timestamp\r\n    }\r\n  }\r\n\r\n  return normalizedValue\r\n}\r\n\r\nfunction compareSortValues(leftValue: SortValue, rightValue: SortValue): number {\r\n  if (leftValue === null && rightValue === null) {\r\n    return 0\r\n  }\r\n\r\n  if (leftValue === null) {\r\n    return -1\r\n  }\r\n\r\n  if (rightValue === null) {\r\n    return 1\r\n  }\r\n\r\n  if (typeof leftValue === 'number' && typeof rightValue === 'number') {\r\n    if (leftValue === rightValue) {\r\n      return 0\r\n    }\r\n\r\n    return leftValue < rightValue ? -1 : 1\r\n  }\r\n\r\n  return String(leftValue).localeCompare(String(rightValue), undefined, {\r\n    numeric: true,\r\n    sensitivity: 'base',\r\n  })\r\n}\r\n\r\nfunction createTreeNodeComparator(sort?: string) {\r\n  const sortTokens = parseSortTokens(sort)\r\n\r\n  if (sortTokens.length === 0) {\r\n    return null\r\n  }\r\n\r\n  return (leftNode: TreeNode, rightNode: TreeNode): number => {\r\n    for (const sortToken of sortTokens) {\r\n      const leftValue = resolveSortValue(leftNode.doc, sortToken.path)\r\n      const rightValue = resolveSortValue(rightNode.doc, sortToken.path)\r\n\r\n      if (leftValue === undefined || rightValue === undefined) {\r\n        continue\r\n      }\r\n\r\n      const comparison = compareSortValues(leftValue, rightValue)\r\n\r\n      if (comparison !== 0) {\r\n        return sortToken.descending ? -comparison : comparison\r\n      }\r\n    }\r\n\r\n    return leftNode.originalIndex - rightNode.originalIndex\r\n  }\r\n}\r\n\r\nexport function buildPageTreeDocs(\r\n  docs: PageTreeSourceDoc[],\r\n  options: BuildPageTreeDocsOptions = {},\r\n): PageTreeDoc[] {\r\n  const parentFieldSlug = options.parentFieldSlug ?? 'parent'\r\n  const nodes: TreeNode[] = docs.map((doc, index) => ({\r\n    doc,\r\n    id: stringifyDocID(doc.id),\r\n    originalIndex: index,\r\n    parentID: getDocParentID(doc, parentFieldSlug),\r\n  }))\r\n  const nodesByID = new Map(nodes.map((node) => [node.id, node]))\r\n  const cycleNodeIDs = getCycleNodeIDs(nodes, nodesByID)\r\n  const effectiveParentIDByNodeID = new Map<string, null | string>()\r\n  const childrenByParentID = new Map<null | string, TreeNode[]>()\r\n  const compareTreeNodes = createTreeNodeComparator(options.sort)\r\n\r\n  for (const node of nodes) {\r\n    const parentExists = node.parentID !== null && nodesByID.has(node.parentID)\r\n    const effectiveParentID =\r\n      parentExists && !cycleNodeIDs.has(node.id) ? node.parentID : null\r\n\r\n    effectiveParentIDByNodeID.set(node.id, effectiveParentID)\r\n\r\n    const currentChildren = childrenByParentID.get(effectiveParentID) ?? []\r\n    currentChildren.push(node)\r\n    childrenByParentID.set(effectiveParentID, currentChildren)\r\n  }\r\n\r\n  if (compareTreeNodes) {\r\n    for (const children of childrenByParentID.values()) {\r\n      children.sort(compareTreeNodes)\r\n    }\r\n  }\r\n\r\n  const orderedDocs: PageTreeDoc[] = []\r\n  const subtreeDepthByID = new Map<string, number>()\r\n  const visitedNodeIDs = new Set<string>()\r\n\r\n  const getShadeLevel = (rootMaxDepth: number, depth: number): number => {\r\n    if (rootMaxDepth === 0) {\r\n      return 0\r\n    }\r\n\r\n    return Math.max(rootMaxDepth - depth + 1, 1)\r\n  }\r\n\r\n  const getSubtreeDepth = (node: TreeNode): number => {\r\n    const cachedDepth = subtreeDepthByID.get(node.id)\r\n\r\n    if (typeof cachedDepth === 'number') {\r\n      return cachedDepth\r\n    }\r\n\r\n    const children = childrenByParentID.get(node.id) ?? []\r\n\r\n    if (children.length === 0) {\r\n      subtreeDepthByID.set(node.id, 0)\r\n      return 0\r\n    }\r\n\r\n    const depth = Math.max(...children.map((child) => getSubtreeDepth(child) + 1))\r\n    subtreeDepthByID.set(node.id, depth)\r\n    return depth\r\n  }\r\n\r\n  const visit = (node: TreeNode, ancestorIDs: string[], rootMaxDepth: number) => {\r\n    if (visitedNodeIDs.has(node.id)) {\r\n      return\r\n    }\r\n\r\n    visitedNodeIDs.add(node.id)\r\n\r\n    const children = childrenByParentID.get(node.id) ?? []\r\n    const depth = ancestorIDs.length\r\n    const shadeLevel = getShadeLevel(rootMaxDepth, depth)\r\n\r\n    orderedDocs.push({\r\n      ...(node.doc as PageTreeSourceDoc),\r\n      __pageTreeAncestorIDs: ancestorIDs,\r\n      __pageTreeDepth: depth,\r\n      __pageTreeHasChildren: children.length > 0,\r\n      __pageTreeID: node.id,\r\n      __pageTreeOrderIndex: orderedDocs.length,\r\n      __pageTreeParentID: effectiveParentIDByNodeID.get(node.id) ?? null,\r\n      __pageTreeShadeLevel: shadeLevel,\r\n    })\r\n\r\n    for (const child of children) {\r\n      visit(child, [...ancestorIDs, node.id], rootMaxDepth)\r\n    }\r\n  }\r\n\r\n  const roots = [...(childrenByParentID.get(null) ?? [])]\r\n\r\n  for (const root of roots) {\r\n    visit(root, [], getSubtreeDepth(root))\r\n  }\r\n\r\n  const fallbackNodes = compareTreeNodes ? [...nodes].sort(compareTreeNodes) : nodes\r\n\r\n  for (const node of fallbackNodes) {\r\n    if (!visitedNodeIDs.has(node.id)) {\r\n      visit(node, [], getSubtreeDepth(node))\r\n    }\r\n  }\r\n\r\n  return orderedDocs\r\n}\r\n\r\nexport function getVisibleTreeDocs(\r\n  docs: PageTreeDoc[],\r\n  collapsedIDs: ReadonlySet<string>,\r\n): PageTreeDoc[] {\r\n  return docs.filter((doc) =>\r\n    doc.__pageTreeAncestorIDs.every((ancestorID) => !collapsedIDs.has(ancestorID)),\r\n  )\r\n}\r\n"],"names":["dateLikePattern","stringifyDocID","id","String","getRelationshipID","value","relationshipID","getDocParentID","doc","parentFieldSlug","getDocDisplayLabel","title","trim","length","slug","__pageTreeID","getDocSlugSegment","replace","buildDocSlugPath","args","docsByID","segments","__pageTreeAncestorIDs","map","ancestorID","get","filter","ancestorDoc","Boolean","push","join","buildProspectiveDocSlugPath","activeDoc","targetDoc","buildChildrenByParentID","docs","childrenByParentID","Map","docID","parentID","existingChildren","set","collectDescendantIDs","rootID","descendantIDs","stack","currentID","pop","getCycleNodeIDs","nodes","nodesByID","cycleNodeIDs","Set","pathStack","visitState","walk","node","currentState","cycleStartIndex","lastIndexOf","cycleIDs","slice","cycleID","add","parentNode","parseSortTokens","sort","split","token","descending","startsWith","normalizedToken","path","resolveSortValue","source","currentValue","segment","Array","isArray","undefined","Date","timestamp","getTime","Number","isNaN","isFinite","normalizedValue","test","parse","compareSortValues","leftValue","rightValue","localeCompare","numeric","sensitivity","createTreeNodeComparator","sortTokens","leftNode","rightNode","sortToken","comparison","originalIndex","buildPageTreeDocs","options","index","effectiveParentIDByNodeID","compareTreeNodes","parentExists","has","effectiveParentID","currentChildren","children","values","orderedDocs","subtreeDepthByID","visitedNodeIDs","getShadeLevel","rootMaxDepth","depth","Math","max","getSubtreeDepth","cachedDepth","child","visit","ancestorIDs","shadeLevel","__pageTreeDepth","__pageTreeHasChildren","__pageTreeOrderIndex","__pageTreeParentID","__pageTreeShadeLevel","roots","root","fallbackNodes","getVisibleTreeDocs","collapsedIDs","every"],"mappings":"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"}

package/dist/utilities/pageTreeCollision.d.ts

@@ -0,0 +1,16 @@
+import { type Collision, type CollisionDetection } from '@dnd-kit/core';
+import type { PageTreeDropTarget } from './dropTargets.js';
+export declare const PAGE_TREE_INSERT_EDGE_SIZE_PX = 6;
+export type PageTreePointerCollisionCandidate = {
+    dropTarget?: PageTreeDropTarget;
+    id: Collision['id'];
+    rect?: {
+        bottom: number;
+        top: number;
+    };
+};
+export declare function resolvePageTreePointerCollisionID(args: {
+    collisions: PageTreePointerCollisionCandidate[];
+    pointerCoordinates: Parameters<CollisionDetection>[0]['pointerCoordinates'];
+}): Collision['id'] | null;
+export declare const pageTreeCollisionDetectionStrategy: CollisionDetection;

package/dist/utilities/pageTreeCollision.js

@@ -0,0 +1,70 @@
+import { closestCenter, pointerWithin } from '@dnd-kit/core';
+export const PAGE_TREE_INSERT_EDGE_SIZE_PX = 6;
+function getResolvedCollision(args) {
+    const { collisionID, droppableContainers, pointerCollisions } = args;
+    const existingPointerCollision = pointerCollisions.find((collision)=>collision.id === collisionID);
+    if (existingPointerCollision) {
+        return existingPointerCollision;
+    }
+    const droppableContainer = droppableContainers.find((container)=>container.id === collisionID);
+    if (!droppableContainer) {
+        return null;
+    }
+    return {
+        id: collisionID,
+        data: {
+            droppableContainer,
+            value: 0
+        }
+    };
+}
+function isRowCollision(collision) {
+    return collision.dropTarget?.dropType === 'row' && Boolean(collision.rect);
+}
+export function resolvePageTreePointerCollisionID(args) {
+    const { collisions, pointerCoordinates } = args;
+    if (!pointerCoordinates) {
+        return null;
+    }
+    const directInsertCollision = collisions.find((collision)=>collision.dropTarget?.dropType === 'insert');
+    if (directInsertCollision) {
+        return directInsertCollision.id;
+    }
+    const rowCollision = collisions.find(isRowCollision);
+    if (!rowCollision) {
+        return null;
+    }
+    if (pointerCoordinates.y - rowCollision.rect.top <= PAGE_TREE_INSERT_EDGE_SIZE_PX) {
+        return rowCollision.dropTarget.insertBeforeDropID;
+    }
+    if (rowCollision.rect.bottom - pointerCoordinates.y <= PAGE_TREE_INSERT_EDGE_SIZE_PX) {
+        return rowCollision.dropTarget.insertAfterDropID;
+    }
+    return rowCollision.id;
+}
+export const pageTreeCollisionDetectionStrategy = (args)=>{
+    const pointerCollisions = pointerWithin(args);
+    const resolvedCollisionID = resolvePageTreePointerCollisionID({
+        collisions: pointerCollisions.map((collision)=>({
+                id: collision.id,
+                dropTarget: collision.data?.droppableContainer.data.current,
+                rect: args.droppableRects.get(collision.id) ?? undefined
+            })),
+        pointerCoordinates: args.pointerCoordinates
+    });
+    if (resolvedCollisionID !== null) {
+        const resolvedCollision = getResolvedCollision({
+            collisionID: resolvedCollisionID,
+            droppableContainers: args.droppableContainers,
+            pointerCollisions
+        });
+        if (resolvedCollision) {
+            return [
+                resolvedCollision
+            ];
+        }
+    }
+    return closestCenter(args);
+};
+
+//# sourceMappingURL=pageTreeCollision.js.map

package/dist/utilities/pageTreeCollision.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/pageTreeCollision.ts"],"sourcesContent":["import {\n  closestCenter,\n  type Collision,\n  type CollisionDetection,\n  pointerWithin,\n} from '@dnd-kit/core'\n\nimport type { PageTreeDropTarget, PageTreeRowDropTarget } from './dropTargets.js'\n\nexport const PAGE_TREE_INSERT_EDGE_SIZE_PX = 6\n\nexport type PageTreePointerCollisionCandidate = {\n  dropTarget?: PageTreeDropTarget\n  id: Collision['id']\n  rect?: {\n    bottom: number\n    top: number\n  }\n}\n\nfunction getResolvedCollision(args: {\n  collisionID: Collision['id']\n  droppableContainers: Parameters<CollisionDetection>[0]['droppableContainers']\n  pointerCollisions: Collision[]\n}): Collision | null {\n  const { collisionID, droppableContainers, pointerCollisions } = args\n  const existingPointerCollision = pointerCollisions.find((collision) => collision.id === collisionID)\n\n  if (existingPointerCollision) {\n    return existingPointerCollision\n  }\n\n  const droppableContainer = droppableContainers.find((container) => container.id === collisionID)\n\n  if (!droppableContainer) {\n    return null\n  }\n\n  return {\n    id: collisionID,\n    data: {\n      droppableContainer,\n      value: 0,\n    },\n  }\n}\n\ntype PageTreeResolvedRowCollision = {\n  dropTarget: PageTreeRowDropTarget\n  rect: {\n    bottom: number\n    top: number\n  }\n} & PageTreePointerCollisionCandidate\n\nfunction isRowCollision(\n  collision: PageTreePointerCollisionCandidate,\n): collision is PageTreeResolvedRowCollision {\n  return collision.dropTarget?.dropType === 'row' && Boolean(collision.rect)\n}\n\nexport function resolvePageTreePointerCollisionID(args: {\n  collisions: PageTreePointerCollisionCandidate[]\n  pointerCoordinates: Parameters<CollisionDetection>[0]['pointerCoordinates']\n}): Collision['id'] | null {\n  const { collisions, pointerCoordinates } = args\n\n  if (!pointerCoordinates) {\n    return null\n  }\n\n  const directInsertCollision = collisions.find((collision) => collision.dropTarget?.dropType === 'insert')\n\n  if (directInsertCollision) {\n    return directInsertCollision.id\n  }\n\n  const rowCollision = collisions.find(isRowCollision)\n\n  if (!rowCollision) {\n    return null\n  }\n\n  if (pointerCoordinates.y - rowCollision.rect.top <= PAGE_TREE_INSERT_EDGE_SIZE_PX) {\n    return rowCollision.dropTarget.insertBeforeDropID\n  }\n\n  if (rowCollision.rect.bottom - pointerCoordinates.y <= PAGE_TREE_INSERT_EDGE_SIZE_PX) {\n    return rowCollision.dropTarget.insertAfterDropID\n  }\n\n  return rowCollision.id\n}\n\nexport const pageTreeCollisionDetectionStrategy: CollisionDetection = (args) => {\n  const pointerCollisions = pointerWithin(args)\n  const resolvedCollisionID = resolvePageTreePointerCollisionID({\n    collisions: pointerCollisions.map((collision) => ({\n      id: collision.id,\n      dropTarget: collision.data?.droppableContainer.data.current as PageTreeDropTarget | undefined,\n      rect: args.droppableRects.get(collision.id) ?? undefined,\n    })),\n    pointerCoordinates: args.pointerCoordinates,\n  })\n\n  if (resolvedCollisionID !== null) {\n    const resolvedCollision = getResolvedCollision({\n      collisionID: resolvedCollisionID,\n      droppableContainers: args.droppableContainers,\n      pointerCollisions,\n    })\n\n    if (resolvedCollision) {\n      return [resolvedCollision]\n    }\n  }\n\n  return closestCenter(args)\n}\n"],"names":["closestCenter","pointerWithin","PAGE_TREE_INSERT_EDGE_SIZE_PX","getResolvedCollision","args","collisionID","droppableContainers","pointerCollisions","existingPointerCollision","find","collision","id","droppableContainer","container","data","value","isRowCollision","dropTarget","dropType","Boolean","rect","resolvePageTreePointerCollisionID","collisions","pointerCoordinates","directInsertCollision","rowCollision","y","top","insertBeforeDropID","bottom","insertAfterDropID","pageTreeCollisionDetectionStrategy","resolvedCollisionID","map","current","droppableRects","get","undefined","resolvedCollision"],"mappings":"AAAA,SACEA,aAAa,EAGbC,aAAa,QACR,gBAAe;AAItB,OAAO,MAAMC,gCAAgC,EAAC;AAW9C,SAASC,qBAAqBC,IAI7B;IACC,MAAM,EAAEC,WAAW,EAAEC,mBAAmB,EAAEC,iBAAiB,EAAE,GAAGH;IAChE,MAAMI,2BAA2BD,kBAAkBE,IAAI,CAAC,CAACC,YAAcA,UAAUC,EAAE,KAAKN;IAExF,IAAIG,0BAA0B;QAC5B,OAAOA;IACT;IAEA,MAAMI,qBAAqBN,oBAAoBG,IAAI,CAAC,CAACI,YAAcA,UAAUF,EAAE,KAAKN;IAEpF,IAAI,CAACO,oBAAoB;QACvB,OAAO;IACT;IAEA,OAAO;QACLD,IAAIN;QACJS,MAAM;YACJF;YACAG,OAAO;QACT;IACF;AACF;AAUA,SAASC,eACPN,SAA4C;IAE5C,OAAOA,UAAUO,UAAU,EAAEC,aAAa,SAASC,QAAQT,UAAUU,IAAI;AAC3E;AAEA,OAAO,SAASC,kCAAkCjB,IAGjD;IACC,MAAM,EAAEkB,UAAU,EAAEC,kBAAkB,EAAE,GAAGnB;IAE3C,IAAI,CAACmB,oBAAoB;QACvB,OAAO;IACT;IAEA,MAAMC,wBAAwBF,WAAWb,IAAI,CAAC,CAACC,YAAcA,UAAUO,UAAU,EAAEC,aAAa;IAEhG,IAAIM,uBAAuB;QACzB,OAAOA,sBAAsBb,EAAE;IACjC;IAEA,MAAMc,eAAeH,WAAWb,IAAI,CAACO;IAErC,IAAI,CAACS,cAAc;QACjB,OAAO;IACT;IAEA,IAAIF,mBAAmBG,CAAC,GAAGD,aAAaL,IAAI,CAACO,GAAG,IAAIzB,+BAA+B;QACjF,OAAOuB,aAAaR,UAAU,CAACW,kBAAkB;IACnD;IAEA,IAAIH,aAAaL,IAAI,CAACS,MAAM,GAAGN,mBAAmBG,CAAC,IAAIxB,+BAA+B;QACpF,OAAOuB,aAAaR,UAAU,CAACa,iBAAiB;IAClD;IAEA,OAAOL,aAAad,EAAE;AACxB;AAEA,OAAO,MAAMoB,qCAAyD,CAAC3B;IACrE,MAAMG,oBAAoBN,cAAcG;IACxC,MAAM4B,sBAAsBX,kCAAkC;QAC5DC,YAAYf,kBAAkB0B,GAAG,CAAC,CAACvB,YAAe,CAAA;gBAChDC,IAAID,UAAUC,EAAE;gBAChBM,YAAYP,UAAUI,IAAI,EAAEF,mBAAmBE,KAAKoB;gBACpDd,MAAMhB,KAAK+B,cAAc,CAACC,GAAG,CAAC1B,UAAUC,EAAE,KAAK0B;YACjD,CAAA;QACAd,oBAAoBnB,KAAKmB,kBAAkB;IAC7C;IAEA,IAAIS,wBAAwB,MAAM;QAChC,MAAMM,oBAAoBnC,qBAAqB;YAC7CE,aAAa2B;YACb1B,qBAAqBF,KAAKE,mBAAmB;YAC7CC;QACF;QAEA,IAAI+B,mBAAmB;YACrB,OAAO;gBAACA;aAAkB;QAC5B;IACF;IAEA,OAAOtC,cAAcI;AACvB,EAAC"}

package/dist/utilities/pageTreeConfig.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionConfig } from 'payload';
+import type { NestedDocsPageTreePluginCollectionCustom } from '../types.js';
+export declare function getCollectionPageTreeConfig(collection: Pick<CollectionConfig, 'custom'>): null | NestedDocsPageTreePluginCollectionCustom;