@powerhousedao/network-admin 1.0.0-dev.6 → 1.0.0-dev.7

package/dist/document-models/workstream/v1/tests/document-model.test.js

@@ -0,0 +1,104 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import { utils, initialGlobalState, initialLocalState, workstreamDocumentType, isWorkstreamDocument, assertIsWorkstreamDocument, isWorkstreamState, assertIsWorkstreamState, } from "@powerhousedao/network-admin/document-models/workstream/v1";
+import { ZodError } from "zod";
+describe("Workstream Document Model", () => {
+    it("should create a new Workstream document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(workstreamDocumentType);
+    });
+    it("should create a new Workstream document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isWorkstreamDocument(document)).toBe(true);
+        expect(isWorkstreamState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a Workstream document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsWorkstreamDocument(wrongDocumentType)).toThrow();
+            expect(isWorkstreamDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    const wrongState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongState.state.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isWorkstreamState(wrongState.state)).toBe(false);
+        expect(assertIsWorkstreamState(wrongState.state)).toThrow();
+        expect(isWorkstreamDocument(wrongState)).toBe(false);
+        expect(assertIsWorkstreamDocument(wrongState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const wrongInitialState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongInitialState.initialState.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isWorkstreamState(wrongInitialState.state)).toBe(false);
+        expect(assertIsWorkstreamState(wrongInitialState.state)).toThrow();
+        expect(isWorkstreamDocument(wrongInitialState)).toBe(false);
+        expect(assertIsWorkstreamDocument(wrongInitialState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingIdInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingIdInHeader.header.id;
+    try {
+        expect(isWorkstreamDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsWorkstreamDocument(missingIdInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingNameInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingNameInHeader.header.name;
+    try {
+        expect(isWorkstreamDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsWorkstreamDocument(missingNameInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+    try {
+        expect(isWorkstreamDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsWorkstreamDocument(missingCreatedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+    try {
+        expect(isWorkstreamDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsWorkstreamDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/workstream/v1/tests/proposals.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/v1/tests/proposals.test.ts"],"names":[],"mappings":""}

package/dist/document-models/workstream/v1/tests/proposals.test.js

@@ -0,0 +1,45 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isWorkstreamDocument, editInitialProposal, addAlternativeProposal, editAlternativeProposal, removeAlternativeProposal, EditInitialProposalInputSchema, AddAlternativeProposalInputSchema, EditAlternativeProposalInputSchema, RemoveAlternativeProposalInputSchema, } from "@powerhousedao/network-admin/document-models/workstream/v1";
+describe("ProposalsOperations", () => {
+    it("should handle editInitialProposal operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(EditInitialProposalInputSchema());
+        const updatedDocument = reducer(document, editInitialProposal(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_INITIAL_PROPOSAL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addAlternativeProposal operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, addAlternativeProposal(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle editAlternativeProposal operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(EditAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, editAlternativeProposal(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeAlternativeProposal operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, removeAlternativeProposal(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/workstream/v1/tests/workstream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workstream.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/v1/tests/workstream.test.ts"],"names":[],"mappings":""}

package/dist/document-models/workstream/v1/tests/workstream.test.js

@@ -0,0 +1,58 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isWorkstreamDocument, editWorkstream, editClientInfo, setRequestForProposal, addPaymentRequest, removePaymentRequest, EditWorkstreamInputSchema, EditClientInfoInputSchema, SetRequestForProposalInputSchema, AddPaymentRequestInputSchema, RemovePaymentRequestInputSchema, } from "@powerhousedao/network-admin/document-models/workstream/v1";
+describe("WorkstreamOperations", () => {
+    it("should handle editWorkstream operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(EditWorkstreamInputSchema());
+        const updatedDocument = reducer(document, editWorkstream(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_WORKSTREAM");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle editClientInfo operation", () => {
+        const document = utils.createDocument();
+        const input = {
+            ...generateMock(EditClientInfoInputSchema()),
+            icon: "https://example.com/icon.png",
+        };
+        const updatedDocument = reducer(document, editClientInfo(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_CLIENT_INFO");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setRequestForProposal operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetRequestForProposalInputSchema());
+        const updatedDocument = reducer(document, setRequestForProposal(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_REQUEST_FOR_PROPOSAL");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addPaymentRequest operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddPaymentRequestInputSchema());
+        const updatedDocument = reducer(document, addPaymentRequest(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_PAYMENT_REQUEST");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removePaymentRequest operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemovePaymentRequestInputSchema());
+        const updatedDocument = reducer(document, removePaymentRequest(input));
+        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_PAYMENT_REQUEST");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/workstream/v1/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../document-models/workstream/v1/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,8CAA8C;AAC9C,eAAO,MAAM,KAAK;;;;;;;;;;CAG+B,CAAC"}

package/dist/editors/builders-editor/editor.d.ts

@@ -0,0 +1,3 @@
+/** Implement your editor behavior here */
+export default function Editor(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=editor.d.ts.map

package/dist/editors/builders-editor/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../editors/builders-editor/editor.tsx"],"names":[],"mappings":"AAkJA,0CAA0C;AAC1C,MAAM,CAAC,OAAO,UAAU,MAAM,4CAkT7B"}

package/dist/editors/builders-editor/editor.js

@@ -0,0 +1,284 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DocumentToolbar } from "@powerhousedao/design-system/connect";
+import { useSelectedBuildersDocument, actions as buildersActions, } from "@powerhousedao/network-admin/document-models/builders";
+import { setSelectedNode, useParentFolderForSelectedNode, useDrives, useDocuments, } from "@powerhousedao/reactor-browser";
+import { useMemo, useCallback, useState, useEffect } from "react";
+import { ObjectSetTable, PHIDInput, } from "@powerhousedao/document-engineering";
+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.
+ */
+function BuilderPHIDInput({ initialPhid, options, onSave, fetchOptionsCallback, }) {
+    const [inputText, setInputText] = useState("");
+    const [hasSaved, setHasSaved] = useState(false);
+    useEffect(() => {
+        setInputText("");
+        setHasSaved(false);
+    }, [initialPhid]);
+    const findPhidByInput = useCallback((input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return null;
+        const lowerInput = trimmed.toLowerCase();
+        const exactMatchByName = options.find((opt) => opt.label.toLowerCase() === lowerInput);
+        if (exactMatchByName)
+            return exactMatchByName.id;
+        const partialMatchByName = options.find((opt) => opt.label.toLowerCase().startsWith(lowerInput));
+        if (partialMatchByName)
+            return partialMatchByName.id;
+        const containsMatches = options.filter((opt) => opt.label.toLowerCase().includes(lowerInput));
+        if (containsMatches.length === 1)
+            return containsMatches[0].id;
+        const matchById = options.find((opt) => opt.id.toLowerCase() === lowerInput);
+        if (matchById)
+            return matchById.id;
+        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]);
+    const isKnownPhid = useCallback((value) => {
+        return options.some((opt) => opt.id === value);
+    }, [options]);
+    const savePhid = useCallback((phid) => {
+        if (!hasSaved && phid && phid !== initialPhid) {
+            setHasSaved(true);
+            onSave(phid);
+        }
+    }, [hasSaved, initialPhid, onSave]);
+    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) => {
+            if (isKnownPhid(newValue)) {
+                savePhid(newValue);
+            }
+        }, onInput: (e) => {
+            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 }));
+}
+/** Implement your editor behavior here */
+export default function Editor() {
+    const [doc, dispatch] = useSelectedBuildersDocument();
+    // Get the parent folder node for the currently selected node
+    const parentFolder = useParentFolderForSelectedNode();
+    // Set the selected node to the parent folder node (close the editor)
+    function handleClose() {
+        setSelectedNode(parentFolder?.id);
+    }
+    const drives = useDrives();
+    // 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 = useDocuments(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 builders 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 builders = useMemo(() => {
+        return (doc?.state.global.builders.map((phid) => {
+            const profile = getBuilderProfileByPhid(phid);
+            return {
+                phid: phid,
+                name: profile?.name || "",
+                slug: profile?.slug || "",
+                icon: profile?.icon || null,
+            };
+        }) || []);
+    }, [doc, 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 builder
+                    dispatch(buildersActions.removeBuilder({ builderPhid: currentId }));
+                    // Then add the new builder with the new PHID
+                    dispatch(buildersActions.addBuilder({
+                        builderPhid: 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 existingBuilder = builders.find((builder) => builder.phid === phidValue);
+                        if (!existingBuilder) {
+                            // If we're editing an existing row (has an ID), remove the old one first
+                            if (currentPhid && currentPhid !== phidValue) {
+                                dispatch(buildersActions.removeBuilder({
+                                    builderPhid: currentPhid,
+                                }));
+                            }
+                            // Add the new builder
+                            dispatch(buildersActions.addBuilder({
+                                builderPhid: 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(BuilderPHIDInput, { 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 builder (enter or click outside to save)" }));
+                }
+                return _jsx("div", { className: "text-center font-mono text-sm", children: value });
+            },
+        },
+        {
+            field: "name",
+            title: "Builder Name",
+            editable: false,
+            align: "center",
+            width: 200,
+            renderCell: (value) => {
+                return _jsx("div", { className: "text-center", children: value });
+            },
+        },
+        {
+            field: "slug",
+            title: "Builder 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: "Builder icon", className: "w-10 h-10 rounded-sm mx-auto object-cover", onError: (e) => {
+                            e.currentTarget.style.display = "none";
+                        } }) }));
+            },
+        },
+    ], [builders, getBuilderProfiles, dispatch]);
+    return (_jsxs("div", { className: "w-full bg-gray-50", children: [_jsx(DocumentToolbar, {}), _jsxs("div", { className: "p-2 max-w-4xl mx-auto min-h-screen", children: [_jsx("div", { className: "bg-white rounded-lg p-6 mb-6 shadow-sm text-center", children: _jsx("h1", { className: "text-3xl font-bold text-gray-900 mb-2", children: "Builders" }) }), _jsx("div", { className: "mt-4 bg-white", children: _jsx(ObjectSetTable, { columns: columns, data: builders, allowRowSelection: true, onDelete: (data) => {
+                                if (data.length > 0) {
+                                    data.forEach((d) => {
+                                        dispatch(buildersActions.removeBuilder({ builderPhid: d.phid }));
+                                    });
+                                }
+                            }, onAdd: (data) => {
+                                // Only add if we have a PHID
+                                const phid = data.id;
+                                if (phid) {
+                                    dispatch(buildersActions.addBuilder({
+                                        builderPhid: phid,
+                                    }));
+                                }
+                            } }) })] })] }));
+}

package/dist/editors/builders-editor/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/builders-editor/hooks/useRemoteBuilderProfiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteBuilderProfiles.d.ts","sourceRoot":"","sources":["../../../../editors/builders-editor/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/builders-editor/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,
+    };
+}

package/dist/editors/builders-editor/module.d.ts

@@ -0,0 +1,3 @@
+import type { EditorModule } from "document-model";
+export declare const BuildersEditor: EditorModule;
+//# sourceMappingURL=module.d.ts.map

package/dist/editors/builders-editor/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../editors/builders-editor/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,eAAO,MAAM,cAAc,EAAE,YAO5B,CAAC"}

package/dist/editors/builders-editor/module.js

@@ -0,0 +1,9 @@
+import { lazy } from "react";
+export const BuildersEditor = {
+    Component: lazy(() => import("./editor.js")),
+    documentTypes: ["powerhouse/builders"],
+    config: {
+        id: "builders-editor",
+        name: "builders",
+    },
+};

package/dist/editors/builders-editor/utils/graphql-client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * GraphQL client utility for fetching remote builder profiles from Switchboard.
+ * This is used as a fallback when local drives don't have the builder profile documents.
+ */
+export interface RemoteBuilderProfile {
+    id: string;
+    state: {
+        name: string | null;
+        slug: string | null;
+        icon: string | null;
+        description: string | null;
+    };
+}
+/**
+ * Fetches a single builder profile by document ID
+ */
+export declare function fetchBuilderProfileById(docId: string): Promise<RemoteBuilderProfile | null>;
+/**
+ * Fetches all builder profiles using BuilderProfile_findDocuments.
+ */
+export declare function fetchAllRemoteBuilderProfiles(): Promise<RemoteBuilderProfile[]>;
+/**
+ * Fetches multiple builder profiles by their IDs.
+ */
+export declare function fetchRemoteBuilderProfilesByIds(phids: string[]): Promise<Map<string, RemoteBuilderProfile>>;
+export interface SetOpHubMemberInput {
+    name: string | null;
+    phid: string | null;
+}
+/**
+ * Sets the operational hub member on a builder profile document.
+ *
+ * @param docId - The builder profile document ID (PHID)
+ * @param input - The operational hub member data (name and phid of the op hub)
+ * @returns true if successful, false otherwise
+ */
+export declare function setOpHubMemberOnBuilderProfile(docId: string, input: SetOpHubMemberInput): Promise<boolean>;
+//# sourceMappingURL=graphql-client.d.ts.map

package/dist/editors/builders-editor/utils/graphql-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../../../../editors/builders-editor/utils/graphql-client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAwHH,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;CACH;AAyCD;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAOtC;AAED;;GAEG;AACH,wBAAsB,6BAA6B,IAAI,OAAO,CAC5D,oBAAoB,EAAE,CACvB,CAUA;AAED;;GAEG;AACH,wBAAsB,+BAA+B,CACnD,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CA+B5C;AASD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAMD;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,OAAO,CAAC,CAWlB"}