@powerhousedao/contributor-billing 0.1.31 → 0.1.32

package/dist/editors/builder-team-admin/components/team-members.js

@@ -0,0 +1,309 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useCallback, useState, useEffect } from "react";
+import { useDocumentsInSelectedDrive, useDrives, useGetDocuments, useDocumentById, } from "@powerhousedao/reactor-browser";
+import { ObjectSetTable, PHIDInput, } from "@powerhousedao/document-engineering";
+import { actions as builderProfileActions } from "@powerhousedao/builder-profile/document-models/builder-profile";
+import { useRemoteBuilderProfiles } from "../hooks/useRemoteBuilderProfiles.js";
+/**
+ * Wrapper component for PHIDInput that properly tracks selected PHID
+ * and handles saving on blur/enter with the correct PHID value.
+ *
+ * Key insight from the PHIDInput library:
+ * - onChange is called with the PHID value when user selects from dropdown (click or Enter on highlighted item)
+ * - After dropdown selection, the input is re-focused so onBlur doesn't fire
+ * - Therefore we must save immediately in onChange when a valid PHID is selected
+ */
+function ContributorPHIDInput({ initialPhid, options, onSave, fetchOptionsCallback, }) {
+    // Track the current input text for manual entry lookup
+    const [inputText, setInputText] = useState("");
+    // Track if we already saved to prevent duplicate saves
+    const [hasSaved, setHasSaved] = useState(false);
+    // Reset state when initialPhid changes (switching between rows)
+    useEffect(() => {
+        setInputText("");
+        setHasSaved(false);
+    }, [initialPhid]);
+    // Find PHID by name or return the input if it looks like a PHID
+    const findPhidByInput = useCallback((input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return null;
+        const lowerInput = trimmed.toLowerCase();
+        // Check if input matches a profile name exactly (case-insensitive)
+        const exactMatchByName = options.find((opt) => opt.label.toLowerCase() === lowerInput);
+        if (exactMatchByName)
+            return exactMatchByName.id;
+        // Check if input matches a profile name partially (first match that starts with input)
+        const partialMatchByName = options.find((opt) => opt.label.toLowerCase().startsWith(lowerInput));
+        if (partialMatchByName)
+            return partialMatchByName.id;
+        // Check if only one option contains the input (unambiguous match)
+        const containsMatches = options.filter((opt) => opt.label.toLowerCase().includes(lowerInput));
+        if (containsMatches.length === 1)
+            return containsMatches[0].id;
+        // Check if input matches a profile ID
+        const matchById = options.find((opt) => opt.id.toLowerCase() === lowerInput);
+        if (matchById)
+            return matchById.id;
+        // If input looks like a UUID, return it directly
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (uuidRegex.test(trimmed))
+            return trimmed;
+        return null;
+    }, [options]);
+    // Check if a value is a known PHID from options
+    const isKnownPhid = useCallback((value) => {
+        return options.some((opt) => opt.id === value);
+    }, [options]);
+    // Save a PHID value (with duplicate prevention)
+    const savePhid = useCallback((phid) => {
+        if (!hasSaved && phid && phid !== initialPhid) {
+            setHasSaved(true);
+            onSave(phid);
+        }
+    }, [hasSaved, initialPhid, onSave]);
+    // Handle blur - try to save based on inputText
+    const handleBlur = useCallback(() => {
+        if (hasSaved)
+            return;
+        if (inputText) {
+            const foundPhid = findPhidByInput(inputText);
+            if (foundPhid) {
+                savePhid(foundPhid);
+            }
+        }
+    }, [hasSaved, inputText, findPhidByInput, savePhid]);
+    return (_jsx(PHIDInput, { value: initialPhid, onChange: (newValue) => {
+            // onChange is called when user selects from dropdown (click or Enter on highlighted item)
+            // The newValue is the PHID. Save immediately if it's a valid known PHID.
+            if (isKnownPhid(newValue)) {
+                savePhid(newValue);
+            }
+        }, onInput: (e) => {
+            // Track the raw input text for manual entry lookup on blur
+            const target = e.target;
+            setInputText(target.value);
+        }, onBlur: handleBlur, placeholder: "Enter PHID or search by name", className: "w-full", variant: "withValueAndTitle", initialOptions: options, fetchOptionsCallback: fetchOptionsCallback }));
+}
+export function ContributorsSection({}) {
+    const drives = useDrives();
+    const documentsInSelectedDrive = useDocumentsInSelectedDrive();
+    // find builder-profile document in the selected drive
+    const builderProfileDocument = useMemo(() => {
+        if (!documentsInSelectedDrive)
+            return null;
+        return documentsInSelectedDrive.find((doc) => doc.header.documentType === "powerhouse/builder-profile");
+    }, [documentsInSelectedDrive]);
+    const [buildDoc, dispatch] = useDocumentById(builderProfileDocument?.header.id);
+    const contributors = useMemo(() => {
+        const state = buildDoc?.state;
+        return state?.global?.contributors || [];
+    }, [buildDoc]);
+    // Map all builder profile FileNodes from all drives with their driveId
+    const builderProfileNodesWithDriveId = useMemo(() => {
+        if (!drives)
+            return [];
+        return drives.flatMap((drive) => {
+            const builderProfileNodes = drive.state.global.nodes.filter((node) => node.kind === "file" &&
+                "documentType" in node &&
+                node.documentType === "powerhouse/builder-profile");
+            return builderProfileNodes.map((node) => ({
+                node,
+                driveId: drive.header.id,
+            }));
+        });
+    }, [drives]);
+    // Get all unique builder PHIDs from the nodes
+    const builderPhids = useMemo(() => {
+        return builderProfileNodesWithDriveId.map(({ node }) => node.id);
+    }, [builderProfileNodesWithDriveId]);
+    // Fetch all builder profile documents from all drives
+    const builderProfileDocuments = useGetDocuments(builderPhids);
+    // Create a map of PHID to document for quick lookup (local drives)
+    const localBuilderProfileMap = useMemo(() => {
+        const map = new Map();
+        if (!builderProfileDocuments)
+            return map;
+        builderProfileDocuments.forEach((doc) => {
+            if (doc.header.documentType === "powerhouse/builder-profile") {
+                map.set(doc.header.id, doc);
+            }
+        });
+        return map;
+    }, [builderProfileDocuments]);
+    // Fetch remote profiles as fallback for contributors not found locally
+    const { profileMap: remoteProfileMap, allProfiles: remoteProfiles } = useRemoteBuilderProfiles(localBuilderProfileMap);
+    // Helper function to get builder profile documents from all drives (local + remote)
+    const getBuilderProfiles = useCallback(() => {
+        // Start with local profiles
+        const profileOptions = builderProfileNodesWithDriveId.map(({ node }) => {
+            const doc = localBuilderProfileMap.get(node.id);
+            const name = doc?.state?.global?.name || node.name || node.id;
+            return {
+                id: node.id,
+                label: name,
+                value: node.id,
+                title: name,
+            };
+        });
+        // Add remote profiles that aren't already in local
+        const localIds = new Set(profileOptions.map((p) => p.id));
+        for (const remoteProfile of remoteProfiles) {
+            if (!localIds.has(remoteProfile.id)) {
+                const name = remoteProfile.state?.name || remoteProfile.id;
+                profileOptions.push({
+                    id: remoteProfile.id,
+                    label: name,
+                    value: remoteProfile.id,
+                    title: name,
+                });
+            }
+        }
+        return profileOptions;
+    }, [builderProfileNodesWithDriveId, localBuilderProfileMap, remoteProfiles]);
+    // Helper function to get builder profile data by PHID (local first, then remote fallback)
+    const getBuilderProfileByPhid = useCallback((phid) => {
+        // Try local first
+        const localDoc = localBuilderProfileMap.get(phid);
+        if (localDoc) {
+            return {
+                name: localDoc.state.global?.name || localDoc.header.id,
+                slug: localDoc.state.global?.slug || localDoc.header.id,
+                icon: localDoc.state.global?.icon || null,
+            };
+        }
+        // Fall back to remote
+        const remoteProfile = remoteProfileMap.get(phid);
+        if (remoteProfile) {
+            return {
+                name: remoteProfile.state?.name || remoteProfile.id,
+                slug: remoteProfile.state?.slug || remoteProfile.id,
+                icon: remoteProfile.state?.icon || null,
+            };
+        }
+        return null;
+    }, [localBuilderProfileMap, remoteProfileMap]);
+    const contributorData = useMemo(() => {
+        return contributors.map((phid) => {
+            const profile = getBuilderProfileByPhid(phid);
+            return {
+                phid: phid,
+                name: profile?.name || "",
+                slug: profile?.slug || "",
+                icon: profile?.icon || null,
+            };
+        });
+    }, [contributors, getBuilderProfileByPhid]);
+    const columns = useMemo(() => [
+        {
+            field: "phid",
+            title: "PHID",
+            editable: true,
+            align: "center",
+            width: 200,
+            onSave: (newValue, context) => {
+                const currentId = context.row.phid || "";
+                if (newValue !== currentId && newValue && currentId) {
+                    // First remove the old contributor
+                    dispatch(builderProfileActions.removeContributor({
+                        contributorPHID: currentId,
+                    }));
+                    // Then add the new contributor with the new PHID
+                    dispatch(builderProfileActions.addContributor({
+                        contributorPHID: newValue,
+                    }));
+                    return true;
+                }
+                return false;
+            },
+            renderCellEditor: (_value, _onChange, context) => {
+                const currentPhid = context.row.phid || "";
+                const handleSave = (phidValue) => {
+                    // If a PHID is entered and it's different from current value
+                    if (phidValue && phidValue !== currentPhid) {
+                        const existingContributor = contributors.find((contributor) => contributor === phidValue);
+                        if (!existingContributor) {
+                            // If we're editing an existing row (has an ID), remove the old one first
+                            if (currentPhid && currentPhid !== phidValue) {
+                                dispatch(builderProfileActions.removeContributor({
+                                    contributorPHID: currentPhid,
+                                }));
+                            }
+                            // Add the new contributor
+                            dispatch(builderProfileActions.addContributor({
+                                contributorPHID: phidValue,
+                            }));
+                        }
+                    }
+                };
+                const fetchOptions = (userInput) => {
+                    const builderProfiles = getBuilderProfiles();
+                    // Filter profiles based on user input
+                    if (!userInput.trim()) {
+                        return Promise.resolve(builderProfiles);
+                    }
+                    const filteredProfiles = builderProfiles.filter((profile) => profile.label.toLowerCase().includes(userInput.toLowerCase()) ||
+                        profile.id.toLowerCase().includes(userInput.toLowerCase()));
+                    return Promise.resolve(filteredProfiles);
+                };
+                return (_jsx(ContributorPHIDInput, { initialPhid: currentPhid, options: getBuilderProfiles(), onSave: handleSave, fetchOptionsCallback: fetchOptions }, `phid-input-${currentPhid || Date.now()}`));
+            },
+            renderCell: (value) => {
+                if (value === "" || !value) {
+                    return (_jsx("div", { className: "font-light italic text-gray-500 text-center", children: "+ Double-click to add new contributor (enter or click outside to save)" }));
+                }
+                return _jsx("div", { className: "text-center font-mono text-sm", children: value });
+            },
+        },
+        {
+            field: "name",
+            title: "Name",
+            editable: false,
+            align: "center",
+            width: 200,
+            renderCell: (value) => {
+                return _jsx("div", { className: "text-center", children: value });
+            },
+        },
+        {
+            field: "slug",
+            title: "Slug",
+            editable: false,
+            align: "center",
+            width: 200,
+            renderCell: (value) => {
+                return _jsx("div", { className: "text-center", children: value });
+            },
+        },
+        {
+            field: "icon",
+            title: "Icon",
+            editable: false,
+            align: "center",
+            width: 150,
+            renderCell: (_value, context) => {
+                if (!context.row.icon) {
+                    return null;
+                }
+                return (_jsx("div", { className: "text-center", children: _jsx("img", { src: context.row.icon, alt: "Contributor icon", className: "w-10 h-10 rounded-sm mx-auto object-cover", onError: (e) => {
+                            e.currentTarget.style.display = "none";
+                        } }) }));
+            },
+        },
+    ], [contributors, getBuilderProfiles, dispatch]);
+    return (_jsxs("div", { className: "bg-white rounded-lg p-6 shadow-sm", children: [_jsx("h3", { className: "text-lg font-medium text-gray-900 mb-4", children: "Contributors" }), _jsx("p", { className: "text-sm text-gray-600 mb-4", children: "Add team members to your builder profile. Search for existing builder profiles by name or PHID." }), _jsx(ObjectSetTable, { columns: columns, data: contributorData, allowRowSelection: true, onDelete: (data) => {
+                    if (data.length > 0) {
+                        data.forEach((d) => {
+                            dispatch(builderProfileActions.removeContributor({
+                                contributorPHID: d.phid,
+                            }));
+                        });
+                    }
+                }, onAdd: (data) => {
+                    // Only add if we have a PHID
+                    const phid = data.id;
+                    if (phid) {
+                        dispatch(builderProfileActions.addContributor({ contributorPHID: phid }));
+                    }
+                } })] }));
+}

package/dist/editors/{clean-new-editor → builder-team-admin}/config.d.ts

@@ -1,4 +1,4 @@
 import type { PHDriveEditorConfig } from "@powerhousedao/reactor-browser";
-/** Editor config for the CleanNewEditor */
+/** Editor config for the BuilderTeamAdmin */
 export declare const editorConfig: PHDriveEditorConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/editors/builder-team-admin/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../editors/builder-team-admin/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAE1E,6CAA6C;AAC7C,eAAO,MAAM,YAAY,EAAE,mBAM1B,CAAC"}

package/dist/editors/builder-team-admin/config.js

@@ -0,0 +1,8 @@
+/** Editor config for the BuilderTeamAdmin */
+export const editorConfig = {
+    isDragAndDropEnabled: true,
+    allowedDocumentTypes: [
+        "powerhouse/expense-report",
+        "powerhouse/snapshot-report",
+    ],
+};

package/dist/editors/{clean-new-editor → builder-team-admin}/editor.d.ts

@@ -1,4 +1,4 @@
 import type { EditorProps } from "document-model";
-/** Editor component for the CleanNewEditor drive editor */
+/** Editor component for the BuilderTeamAdmin drive editor */
 export default function Editor(props: EditorProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=editor.d.ts.map

package/dist/editors/builder-team-admin/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../editors/builder-team-admin/editor.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAIlD,6DAA6D;AAC7D,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAK,EAAE,WAAW,2CAKhD"}

package/dist/editors/{clean-new-editor → builder-team-admin}/editor.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useSetPHDriveEditorConfig } from "@powerhousedao/reactor-browser";
 import { DriveExplorer } from "./components/DriveExplorer.js";
 import { editorConfig } from "./config.js";
-/** Editor component for the CleanNewEditor drive editor */
+/** Editor component for the BuilderTeamAdmin drive editor */
 export default function Editor(props) {
     // set the config for this drive editor
     // you can update these configs in `./config.ts`

package/dist/editors/builder-team-admin/hooks/useExpenseReportAutoPlacement.d.ts

@@ -0,0 +1,25 @@
+import type { FolderNode } from "document-drive";
+import type { ExpenseReportDocument } from "../../../document-models/expense-report/gen/types.js";
+interface UseExpenseReportAutoPlacementResult {
+    /** The Expense Reports folder node, or null if it doesn't exist yet */
+    expenseReportsFolder: FolderNode | null;
+    /** Set of all node IDs within the Expense Reports folder tree */
+    expenseReportsFolderNodeIds: Set<string>;
+    /** All expense report documents within the Expense Reports folder */
+    expenseReportDocuments: ExpenseReportDocument[];
+}
+/**
+ * Hook that handles automatic placement of expense report documents into the
+ * "Expense Reports" folder, organized by year based on periodStart.
+ *
+ * This hook:
+ * 1. Creates the "Expense Reports" folder if it doesn't exist
+ * 2. Monitors for expense report documents dropped anywhere in the drive
+ * 3. Automatically moves them into year-based subfolders under "Expense Reports"
+ *
+ * Use this hook in any component that needs the auto-placement behavior,
+ * regardless of the current view (main overview, expense reports view, etc.)
+ */
+export declare function useExpenseReportAutoPlacement(): UseExpenseReportAutoPlacementResult;
+export {};
+//# sourceMappingURL=useExpenseReportAutoPlacement.d.ts.map

package/dist/editors/builder-team-admin/hooks/useExpenseReportAutoPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExpenseReportAutoPlacement.d.ts","sourceRoot":"","sources":["../../../../editors/builder-team-admin/hooks/useExpenseReportAutoPlacement.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAIlG,UAAU,mCAAmC;IAC3C,uEAAuE;IACvE,oBAAoB,EAAE,UAAU,GAAG,IAAI,CAAC;IACxC,iEAAiE;IACjE,2BAA2B,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzC,qEAAqE;IACrE,sBAAsB,EAAE,qBAAqB,EAAE,CAAC;CACjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,IAAI,mCAAmC,CAwNnF"}

package/dist/editors/builder-team-admin/hooks/useExpenseReportAutoPlacement.js

@@ -0,0 +1,180 @@
+import { useEffect, useMemo, useRef } from "react";
+import { isFolderNodeKind, isFileNodeKind, addFolder, useSelectedDrive, useDocumentsInSelectedDrive, useNodeActions, } from "@powerhousedao/reactor-browser";
+const EXPENSE_REPORTS_FOLDER_NAME = "Expense Reports";
+/**
+ * Hook that handles automatic placement of expense report documents into the
+ * "Expense Reports" folder, organized by year based on periodStart.
+ *
+ * This hook:
+ * 1. Creates the "Expense Reports" folder if it doesn't exist
+ * 2. Monitors for expense report documents dropped anywhere in the drive
+ * 3. Automatically moves them into year-based subfolders under "Expense Reports"
+ *
+ * Use this hook in any component that needs the auto-placement behavior,
+ * regardless of the current view (main overview, expense reports view, etc.)
+ */
+export function useExpenseReportAutoPlacement() {
+    const [driveDocument] = useSelectedDrive();
+    const documentsInDrive = useDocumentsInSelectedDrive();
+    const { onMoveNode } = useNodeActions();
+    // Track which documents have been processed for auto-placement
+    const processedDocsRef = useRef(new Set());
+    const hasCreatedFolder = useRef(false);
+    // Find the "Expense Reports" folder in the drive
+    const expenseReportsFolder = useMemo(() => {
+        if (!driveDocument)
+            return null;
+        const nodes = driveDocument.state.global.nodes;
+        return (nodes.find((node) => isFolderNodeKind(node) && node.name === EXPENSE_REPORTS_FOLDER_NAME) ?? null);
+    }, [driveDocument]);
+    // Build a set of all EXPENSE REPORT node IDs within the Expense Reports folder tree
+    // This only includes expense-report documents, not other document types
+    const expenseReportsFolderNodeIds = useMemo(() => {
+        const nodeIds = new Set();
+        if (!expenseReportsFolder || !driveDocument)
+            return nodeIds;
+        const allNodes = driveDocument.state.global.nodes;
+        // Recursively collect folder IDs and expense report file IDs within the Expense Reports folder
+        const collectNodeIds = (parentId) => {
+            nodeIds.add(parentId);
+            for (const node of allNodes) {
+                if (isFolderNodeKind(node) && node.parentFolder === parentId) {
+                    collectNodeIds(node.id);
+                }
+                else if (isFileNodeKind(node) &&
+                    node.parentFolder === parentId &&
+                    node.documentType === "powerhouse/expense-report") {
+                    // Only include expense-report documents, not other types
+                    nodeIds.add(node.id);
+                }
+            }
+        };
+        collectNodeIds(expenseReportsFolder.id);
+        return nodeIds;
+    }, [expenseReportsFolder, driveDocument]);
+    // Filter expense report documents that are inside the Expense Reports folder
+    const expenseReportDocuments = useMemo(() => {
+        if (!documentsInDrive || !driveDocument)
+            return [];
+        // Get file nodes for expense reports in the Expense Reports folder
+        const expenseReportFileNodes = driveDocument.state.global.nodes.filter((node) => isFileNodeKind(node) &&
+            node.documentType === "powerhouse/expense-report" &&
+            expenseReportsFolderNodeIds.has(node.id));
+        // Map file node IDs to their documents
+        const fileNodeIds = new Set(expenseReportFileNodes.map((n) => n.id));
+        return documentsInDrive.filter((doc) => doc.header.documentType === "powerhouse/expense-report" &&
+            fileNodeIds.has(doc.header.id));
+    }, [documentsInDrive, driveDocument, expenseReportsFolderNodeIds]);
+    // Create folder if it doesn't exist
+    useEffect(() => {
+        if (!driveDocument || expenseReportsFolder || hasCreatedFolder.current)
+            return;
+        hasCreatedFolder.current = true;
+        const driveId = driveDocument.header.id;
+        void addFolder(driveId, EXPENSE_REPORTS_FOLDER_NAME);
+    }, [driveDocument, expenseReportsFolder]);
+    // Get year folders that exist directly under the Expense Reports folder
+    const yearFolders = useMemo(() => {
+        if (!driveDocument || !expenseReportsFolder)
+            return new Map();
+        const folders = new Map(); // year string -> folder node
+        for (const node of driveDocument.state.global.nodes) {
+            if (isFolderNodeKind(node) &&
+                node.parentFolder === expenseReportsFolder.id &&
+                /^\d{4}$/.test(node.name) // folder name is a 4-digit year
+            ) {
+                folders.set(node.name, node);
+            }
+        }
+        return folders;
+    }, [driveDocument, expenseReportsFolder]);
+    // Auto-place expense reports into year folders based on periodStart
+    // This monitors ALL expense reports in the drive, not just those in the Expense Reports folder
+    useEffect(() => {
+        if (!driveDocument || !expenseReportsFolder || !documentsInDrive)
+            return;
+        const driveId = driveDocument.header.id;
+        const allNodes = driveDocument.state.global.nodes;
+        // Find ALL expense report file nodes that are NOT inside the Expense Reports folder tree
+        // These need to be moved into the proper location
+        const expenseReportNodesOutsideFolder = allNodes.filter((node) => isFileNodeKind(node) &&
+            node.documentType === "powerhouse/expense-report" &&
+            !expenseReportsFolderNodeIds.has(node.id));
+        // Also check for expense reports directly in the Expense Reports root folder
+        // (these need to be moved to year subfolders)
+        const expenseReportNodesInRoot = allNodes.filter((node) => isFileNodeKind(node) &&
+            node.documentType === "powerhouse/expense-report" &&
+            node.parentFolder === expenseReportsFolder.id);
+        // Combine both sets of nodes that need processing
+        const nodesToProcess = [
+            ...expenseReportNodesOutsideFolder,
+            ...expenseReportNodesInRoot,
+        ];
+        // Process each expense report
+        for (const fileNode of nodesToProcess) {
+            // Skip if already processed
+            if (processedDocsRef.current.has(fileNode.id))
+                continue;
+            // Find the corresponding document to get periodStart
+            const doc = documentsInDrive.find((d) => d.header.documentType === "powerhouse/expense-report" &&
+                d.header.id === fileNode.id);
+            if (!doc)
+                continue;
+            const periodStart = doc.state.global.periodStart;
+            if (!periodStart) {
+                // No period defined - move to root of Expense Reports folder
+                // (this signals something might be wrong with the document)
+                processedDocsRef.current.add(fileNode.id);
+                // Only move if not already in the Expense Reports folder
+                if (!expenseReportsFolderNodeIds.has(fileNode.id)) {
+                    onMoveNode(fileNode, expenseReportsFolder).catch((error) => {
+                        console.error(`Failed to move expense report to Expense Reports folder:`, error);
+                        processedDocsRef.current.delete(fileNode.id);
+                    });
+                }
+                continue;
+            }
+            // Extract year from periodStart
+            const year = new Date(periodStart).getFullYear().toString();
+            // Mark as processed immediately to prevent duplicate processing
+            processedDocsRef.current.add(fileNode.id);
+            // Check if year folder exists
+            const existingYearFolder = yearFolders.get(year);
+            if (existingYearFolder) {
+                // Year folder exists - move the document there
+                onMoveNode(fileNode, existingYearFolder).catch((error) => {
+                    console.error(`Failed to move expense report to ${year} folder:`, error);
+                    // Remove from processed so it can be retried
+                    processedDocsRef.current.delete(fileNode.id);
+                });
+            }
+            else {
+                // Create year folder first, then move the document
+                addFolder(driveId, year, expenseReportsFolder.id)
+                    .then((newFolder) => {
+                    if (newFolder) {
+                        // Move the document to the new year folder
+                        return onMoveNode(fileNode, newFolder);
+                    }
+                })
+                    .catch((error) => {
+                    console.error(`Failed to create ${year} folder or move expense report:`, error);
+                    // Remove from processed so it can be retried
+                    processedDocsRef.current.delete(fileNode.id);
+                });
+            }
+        }
+    }, [
+        driveDocument,
+        expenseReportsFolder,
+        documentsInDrive,
+        expenseReportsFolderNodeIds,
+        yearFolders,
+        onMoveNode,
+    ]);
+    return {
+        expenseReportsFolder,
+        expenseReportsFolderNodeIds,
+        expenseReportDocuments,
+    };
+}

package/dist/editors/builder-team-admin/hooks/useRemoteBuilderProfiles.d.ts

@@ -0,0 +1,20 @@
+import { type RemoteBuilderProfile } from "../utils/graphql-client.js";
+interface UseRemoteBuilderProfilesResult {
+    /** Map of PHID to remote builder profile data */
+    profileMap: Map<string, RemoteBuilderProfile>;
+    /** All available remote profiles for selection */
+    allProfiles: RemoteBuilderProfile[];
+    /** Whether remote data is currently loading */
+    isLoading: boolean;
+    /** Manually refetch all available profiles */
+    refetchAll: () => Promise<void>;
+}
+/**
+ * Hook for fetching builder profiles from remote Switchboard drives.
+ * Used as a fallback when local drives don't have the builder profile documents.
+ *
+ * @param localProfileMap - Map of PHIDs that are already resolved locally (to avoid using remote data for those)
+ */
+export declare function useRemoteBuilderProfiles(localProfileMap: Map<string, unknown>): UseRemoteBuilderProfilesResult;
+export {};
+//# sourceMappingURL=useRemoteBuilderProfiles.d.ts.map

package/dist/editors/builder-team-admin/hooks/useRemoteBuilderProfiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteBuilderProfiles.d.ts","sourceRoot":"","sources":["../../../../editors/builder-team-admin/hooks/useRemoteBuilderProfiles.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC,UAAU,8BAA8B;IACtC,iDAAiD;IACjD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC9C,kDAAkD;IAClD,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC,8BAA8B,CA8DhC"}

package/dist/editors/builder-team-admin/hooks/useRemoteBuilderProfiles.js

@@ -0,0 +1,57 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { fetchAllRemoteBuilderProfiles, } from "../utils/graphql-client.js";
+/**
+ * Hook for fetching builder profiles from remote Switchboard drives.
+ * Used as a fallback when local drives don't have the builder profile documents.
+ *
+ * @param localProfileMap - Map of PHIDs that are already resolved locally (to avoid using remote data for those)
+ */
+export function useRemoteBuilderProfiles(localProfileMap) {
+    const [profileMap, setProfileMap] = useState(new Map());
+    const [allProfiles, setAllProfiles] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    // Track if we've already started fetching to avoid duplicate requests
+    const isFetchingRef = useRef(false);
+    const hasFetchedRef = useRef(false);
+    // Fetch all available profiles
+    const refetchAll = useCallback(async () => {
+        // Prevent concurrent fetches
+        if (isFetchingRef.current) {
+            return;
+        }
+        isFetchingRef.current = true;
+        setIsLoading(true);
+        try {
+            const profiles = await fetchAllRemoteBuilderProfiles();
+            hasFetchedRef.current = true;
+            setAllProfiles(profiles);
+            // Build profile map
+            const newMap = new Map();
+            profiles.forEach((profile) => {
+                newMap.set(profile.id, profile);
+            });
+            setProfileMap(newMap);
+        }
+        catch (error) {
+            console.warn("[useRemoteBuilderProfiles] Failed to fetch profiles:", error);
+        }
+        finally {
+            setIsLoading(false);
+            isFetchingRef.current = false;
+        }
+    }, []);
+    // Auto-fetch all profiles on mount
+    useEffect(() => {
+        if (!hasFetchedRef.current && !isFetchingRef.current) {
+            void refetchAll();
+        }
+    }, [refetchAll]);
+    // Filter out profiles that exist locally from the returned allProfiles
+    const filteredAllProfiles = allProfiles.filter((profile) => !localProfileMap.has(profile.id));
+    return {
+        profileMap,
+        allProfiles: filteredAllProfiles,
+        isLoading,
+        refetchAll,
+    };
+}