@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-4DGCCXD6.js

@@ -0,0 +1,710 @@
+import {
+  createUcanService
+} from "./chunk-7W7UUUIE.js";
+import {
+  sendDirectMessage
+} from "./chunk-TS2LNBF2.js";
+
+// src/mantine/blocks/hooks/hookedActions/registry.ts
+var hookedActionTypesRegistry = /* @__PURE__ */ new Map();
+var blockActionsRegistry = /* @__PURE__ */ new Map();
+function registerHookedActionType(actionType) {
+  hookedActionTypesRegistry.set(actionType.type, actionType);
+}
+function getHookedActionType(type) {
+  return hookedActionTypesRegistry.get(type);
+}
+function getAllHookedActionTypes() {
+  return Array.from(hookedActionTypesRegistry.values());
+}
+function registerBlockActions(blockType, actions) {
+  blockActionsRegistry.set(blockType, actions);
+}
+function getBlockActions(blockType) {
+  return blockActionsRegistry.get(blockType) || [];
+}
+
+// src/mantine/blocks/hooks/hookedActions/useHookedActions.ts
+import { useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
+
+// src/mantine/context/BlocknoteContext.tsx
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+
+// src/mantine/blocks/hooks/hookedActions/utils.ts
+function parseHookedActionsConfig(configString) {
+  if (!configString) return {};
+  try {
+    return JSON.parse(configString);
+  } catch {
+    return {};
+  }
+}
+function stringifyHookedActionsConfig(config) {
+  return JSON.stringify(config);
+}
+function resolveUtilValue(key) {
+  const now = /* @__PURE__ */ new Date();
+  switch (key) {
+    case "currentDate":
+      return now.toISOString().split("T")[0];
+    case "currentDateTime":
+      return now.toISOString();
+    case "currentTime":
+      return now.toTimeString().split(" ")[0];
+    default:
+      return void 0;
+  }
+}
+function resolvePayloadValue(template, payload) {
+  if (!template) return "";
+  const singleMatch = template.match(/^\{\{(payload|util)\.(.+)\}\}$/);
+  if (singleMatch) {
+    const [, namespace, path] = singleMatch;
+    if (namespace === "util") {
+      const value2 = resolveUtilValue(path);
+      return value2 !== void 0 ? value2 : "";
+    }
+    const value = getNestedValue(payload, path);
+    return value !== void 0 ? String(value) : "";
+  }
+  return template.replace(/\{\{(payload|util)\.([^}]+)\}\}/g, (_, namespace, path) => {
+    if (namespace === "util") {
+      const value2 = resolveUtilValue(path);
+      return value2 !== void 0 ? value2 : "";
+    }
+    const value = getNestedValue(payload, path);
+    return value !== void 0 ? String(value) : "";
+  });
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function resolveVariableMappings(variableMappings, payload) {
+  const resolved = {};
+  for (const [key, template] of Object.entries(variableMappings)) {
+    resolved[key] = resolvePayloadValue(template, payload);
+  }
+  return resolved;
+}
+function generateHookedActionId() {
+  return `ha_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function createHookedActionInstance(type) {
+  return {
+    id: generateHookedActionId(),
+    type,
+    enabled: true,
+    config: {},
+    variableMappings: {}
+  };
+}
+
+// src/mantine/blocks/hooks/hookedActions/actionTypes/sendEmail.ts
+var sendEmailAction = {
+  type: "sendEmail",
+  label: "Send Email",
+  description: "Send an email using a Mailgun template",
+  configSchema: [
+    {
+      key: "templateName",
+      label: "Email Template",
+      type: "templateSelect",
+      required: true,
+      description: "Select the Mailgun template to use"
+    },
+    {
+      key: "to",
+      label: "To Address",
+      type: "string",
+      required: true,
+      placeholder: "{{payload.recipientEmail}}",
+      description: "Recipient email address (can use payload variables)"
+    },
+    {
+      key: "subject",
+      label: "Subject",
+      type: "string",
+      required: false,
+      placeholder: "Email subject",
+      description: "Email subject line (optional, can use payload variables)"
+    }
+  ],
+  execute: async (actionConfig, payload, context) => {
+    const { handlers } = context;
+    const { config, variableMappings } = actionConfig;
+    if (!handlers.sendEmail) {
+      console.warn("sendEmail handler not available");
+      return;
+    }
+    if (!config.templateName) {
+      console.warn("sendEmail: No template configured");
+      return;
+    }
+    const resolvedTo = resolvePayloadValue(config.to || "", payload);
+    const resolvedSubject = resolvePayloadValue(config.subject || "", payload);
+    if (!resolvedTo) {
+      console.warn("sendEmail: Missing to address after resolution");
+      return;
+    }
+    const resolvedVariables = resolveVariableMappings(variableMappings, payload);
+    try {
+      await handlers.sendEmail({
+        to: resolvedTo,
+        subject: resolvedSubject,
+        template: config.templateName,
+        templateVersion: config.templateVersion,
+        variables: resolvedVariables
+      });
+      console.log("sendEmail: Email sent successfully");
+    } catch (error) {
+      console.error("sendEmail: Failed to send email", error);
+    }
+  }
+};
+
+// src/mantine/blocks/hooks/hookedActions/actionTypes/addLinkedEntity.ts
+function parseLinkedEntities(entitiesString) {
+  if (!entitiesString || entitiesString === "[]") return [];
+  try {
+    return JSON.parse(entitiesString);
+  } catch {
+    return [];
+  }
+}
+var addLinkedEntityAction = {
+  type: "addLinkedEntity",
+  label: "Add Linked Entity",
+  description: "Add a linked entity reference to a qi/domain.sign action block (e.g., link governance group to domain signing)",
+  configSchema: [
+    {
+      key: "targetBlockId",
+      label: "Target Block",
+      type: "blockSelect",
+      required: true,
+      description: "The qi/domain.sign action block to add the linked entity to",
+      blockTypes: ["action"]
+    },
+    {
+      key: "entityType",
+      label: "Entity Type",
+      type: "string",
+      required: true,
+      placeholder: "governanceGroup",
+      description: "Type identifier for this linked entity"
+    }
+  ],
+  execute: async (actionConfig, payload, context) => {
+    const { editor, sourceBlock } = context;
+    const { config } = actionConfig;
+    const targetBlockId = config.targetBlockId;
+    const entityType = config.entityType || "governanceGroup";
+    if (!targetBlockId) {
+      console.warn("addLinkedEntity: No target block configured");
+      return;
+    }
+    const targetBlock = editor.document.find((block) => block.id === targetBlockId);
+    if (!targetBlock) {
+      console.warn(`addLinkedEntity: Target block not found: ${targetBlockId}`);
+      return;
+    }
+    if (targetBlock.type !== "action" || targetBlock.props?.actionType !== "qi/domain.sign") {
+      console.warn(`addLinkedEntity: Target block ${targetBlockId} is not a qi/domain.sign action block`);
+      return;
+    }
+    const coreAddress = payload.coreAddress;
+    if (!coreAddress) {
+      console.warn("addLinkedEntity: No coreAddress in payload");
+      return;
+    }
+    const linkedEntity = {
+      sourceBlockId: sourceBlock.id,
+      type: entityType,
+      coreAddress,
+      name: payload.name || sourceBlock.props?.title,
+      groupType: payload.groupType,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let parsedInputs = {};
+    try {
+      parsedInputs = targetBlock.props?.inputs ? JSON.parse(targetBlock.props.inputs) : {};
+    } catch {
+      parsedInputs = {};
+    }
+    const existingEntities = parseLinkedEntities(parsedInputs.linkedEntities || "[]");
+    const existingIndex = existingEntities.findIndex((e) => e.sourceBlockId === sourceBlock.id);
+    if (existingIndex >= 0) {
+      existingEntities[existingIndex] = linkedEntity;
+    } else {
+      existingEntities.push(linkedEntity);
+    }
+    parsedInputs.linkedEntities = JSON.stringify(existingEntities);
+    try {
+      editor.updateBlock(targetBlock, {
+        props: {
+          ...targetBlock.props,
+          inputs: JSON.stringify(parsedInputs)
+        }
+      });
+      console.log("addLinkedEntity: Linked entity added successfully");
+    } catch (error) {
+      console.error("addLinkedEntity: Failed to update target block", error);
+    }
+  }
+};
+
+// src/mantine/blocks/hooks/hookedActions/actionTypes/sendMatrixDM.ts
+var sendMatrixDMAction = {
+  type: "sendMatrixDM",
+  label: "Send Matrix DM",
+  description: "Send a direct message via Matrix to an assigned user or a specified DID",
+  configSchema: [
+    {
+      key: "targetDid",
+      label: "Target DID",
+      type: "string",
+      required: true,
+      placeholder: "{{payload.assignedActorDid}}",
+      description: "DID of the recipient (can use payload variables)"
+    },
+    {
+      key: "message",
+      label: "Message",
+      type: "string",
+      required: true,
+      placeholder: "You have a new task to complete",
+      description: "Message body to send (can use payload variables)"
+    }
+  ],
+  execute: async (actionConfig, payload, context) => {
+    const { editor } = context;
+    const { config } = actionConfig;
+    const matrixClient = editor.getMatrixClient?.();
+    if (!matrixClient) {
+      console.warn("sendMatrixDM: Matrix client not available");
+      return;
+    }
+    const resolvedDid = resolvePayloadValue(config.targetDid || "", payload);
+    const resolvedMessage = resolvePayloadValue(config.message || "", payload);
+    if (!resolvedDid) {
+      console.warn("sendMatrixDM: Missing target DID after resolution");
+      return;
+    }
+    if (!resolvedMessage) {
+      console.warn("sendMatrixDM: Missing message after resolution");
+      return;
+    }
+    try {
+      await sendDirectMessage(matrixClient, resolvedDid, resolvedMessage);
+      console.log("sendMatrixDM: DM sent successfully");
+    } catch (error) {
+      console.error("sendMatrixDM: Failed to send DM", error);
+    }
+  }
+};
+
+// src/mantine/blocks/hooks/hookedActions/actionTypes/index.ts
+function registerBuiltInActionTypes() {
+  registerHookedActionType(sendEmailAction);
+  registerHookedActionType(addLinkedEntityAction);
+  registerHookedActionType(sendMatrixDMAction);
+}
+
+// src/mantine/blocks/governanceGroup/actions.ts
+var governanceGroupActions = [
+  {
+    actionId: "create",
+    label: "After Create",
+    description: "Runs after the governance group is successfully created",
+    payloadSchema: [
+      {
+        key: "coreAddress",
+        label: "Core Address",
+        type: "string",
+        description: "The DAO core contract address"
+      },
+      {
+        key: "groupAddress",
+        label: "Group Address",
+        type: "string",
+        description: "The voting group contract address"
+      },
+      {
+        key: "transactionHash",
+        label: "Transaction Hash",
+        type: "string",
+        description: "The blockchain transaction hash"
+      },
+      {
+        key: "groupType",
+        label: "Group Type",
+        type: "string",
+        description: "Type of governance group (categorical, multisig, nftStaking, tokenStaking)"
+      },
+      {
+        key: "name",
+        label: "Group Name",
+        type: "string",
+        description: "The name/title of the governance group"
+      }
+    ]
+  }
+];
+function registerGovernanceGroupActions() {
+  registerBlockActions("governanceGroup", governanceGroupActions);
+}
+
+// src/mantine/blocks/hooks/hookedActions/initialize.ts
+var initialized = false;
+function initializeHookedActions() {
+  if (initialized) {
+    return;
+  }
+  registerBuiltInActionTypes();
+  registerGovernanceGroupActions();
+  initialized = true;
+}
+
+// src/mantine/context/BlocknoteContext.tsx
+var BlocknoteContext = createContext({
+  docType: "flow",
+  flowVersion: "0.3",
+  sharedProposals: {},
+  fetchSharedProposal: async () => {
+    throw new Error("BlocknoteContext not initialized");
+  },
+  invalidateProposal: () => {
+    throw new Error("BlocknoteContext not initialized");
+  },
+  subscribeToProposal: () => void 0,
+  activeDrawerId: null,
+  drawerContent: null,
+  openDrawer: () => {
+    throw new Error("BlocknoteContext not initialized");
+  },
+  closeDrawer: () => {
+    throw new Error("BlocknoteContext not initialized");
+  }
+});
+var getHandlersFromEditor = (editor) => {
+  const editorWithHandlers = editor;
+  return editorWithHandlers?.handlers || editorWithHandlers?._handlers || editorWithHandlers?.blocknoteHandlers || editorWithHandlers?.getHandlers?.() || editorWithHandlers?.getBlocknoteHandlers?.();
+};
+function mergeBlocknoteHandlers(primary, override) {
+  if (!primary) return override;
+  if (!override) return primary;
+  const integrations = primary.integrations || override.integrations ? {
+    ...primary.integrations || {},
+    ...override.integrations || {}
+  } : void 0;
+  return {
+    ...primary,
+    ...override,
+    integrations
+  };
+}
+var BlocknoteProvider = ({
+  children,
+  editor,
+  handlers,
+  blockRequirements,
+  editable,
+  visualizationRenderer,
+  getDynamicListData,
+  dynamicListPanelRenderer,
+  dynamicListRenderer,
+  domainCardRenderer,
+  onFlowStepRefClick,
+  mapConfig,
+  connectedUsers,
+  awarenessInstance,
+  translate,
+  topicActionRuntime
+}) => {
+  const [sharedProposals, setSharedProposals] = useState({});
+  const sharedProposalsRef = useRef({});
+  const [activeDrawerId, setActiveDrawerId] = useState(null);
+  const [drawerContent, setDrawerContent] = useState(null);
+  const editorHandlers = getHandlersFromEditor(editor);
+  const effectiveHandlers = useMemo(() => {
+    return mergeBlocknoteHandlers(editorHandlers, handlers);
+  }, [handlers, editorHandlers]);
+  const docType = editor?.docType || "flow";
+  const flowVersion = editor?.getFlowMetadata?.()?.schema_version || "0.3";
+  const ucanService = useMemo(() => {
+    const delegationStore = editor?._ucanDelegationStore;
+    const invStore = editor?._invocationStore;
+    if (!delegationStore || !invStore || !effectiveHandlers) return null;
+    const hasSigningHandlers = !!(effectiveHandlers.createSignerSession || effectiveHandlers.getPrivateKey || effectiveHandlers.getMnemonic);
+    if (!hasSigningHandlers) return null;
+    const flowOwnerDid = editor?.getFlowOwnerDid?.() || "";
+    const docId = editor?.getFlowMetadata?.()?.doc_id || "";
+    const flowUri = docId ? `ixo:flow:${docId}` : "";
+    return createUcanService({
+      delegationStore,
+      invocationStore: invStore,
+      handlers: {
+        getActiveSignerSession: effectiveHandlers.getActiveSignerSession,
+        createSignerSession: effectiveHandlers.createSignerSession,
+        signWithSession: effectiveHandlers.signWithSession,
+        releaseSignerSession: effectiveHandlers.releaseSignerSession,
+        getPrivateKey: effectiveHandlers.getPrivateKey,
+        getMnemonic: effectiveHandlers.getMnemonic,
+        createDelegationWithSession: effectiveHandlers.createDelegationWithSession,
+        createInvocationWithSession: effectiveHandlers.createInvocationWithSession
+      },
+      flowOwnerDid,
+      flowUri
+    });
+  }, [editor?._ucanDelegationStore, editor?._invocationStore, effectiveHandlers, editor?.getFlowOwnerDid?.(), editor?.getFlowMetadata?.()?.doc_id]);
+  useEffect(() => {
+    if (editor) {
+      editor.getUcanService = () => ucanService;
+    }
+  }, [editor, ucanService]);
+  useEffect(() => {
+    initializeHookedActions();
+  }, []);
+  const analyticsEmittedRef = useRef(false);
+  useEffect(() => {
+    if (analyticsEmittedRef.current) return;
+    if (!effectiveHandlers?.onAnalyticsEvent || !editor) return;
+    analyticsEmittedRef.current = true;
+    effectiveHandlers.onAnalyticsEvent("editor_session_started", {
+      docType,
+      editable: !!editable,
+      flowVersion
+    });
+  }, [effectiveHandlers, editor, docType, editable, flowVersion]);
+  useEffect(() => {
+    sharedProposalsRef.current = sharedProposals;
+  }, [sharedProposals]);
+  const fetchSharedProposal = useCallback(
+    async (proposalId, contractAddress, force = false) => {
+      const cacheKey = `${contractAddress}:${proposalId}`;
+      const cached = sharedProposalsRef.current[cacheKey];
+      if (!force && cached && Date.now() - cached.lastFetched < 3e4 && !cached.error) {
+        return cached.proposal;
+      }
+      setSharedProposals((prev) => ({
+        ...prev,
+        [cacheKey]: { ...prev[cacheKey], loading: true }
+      }));
+      try {
+        if (!effectiveHandlers) {
+          throw new Error("BlocknoteHandlers not provided");
+        }
+        const proposal = await effectiveHandlers.getProposal(contractAddress, proposalId);
+        setSharedProposals((prev) => ({
+          ...prev,
+          [cacheKey]: {
+            proposal,
+            lastFetched: Date.now(),
+            loading: false
+          }
+        }));
+        return proposal;
+      } catch (error) {
+        setSharedProposals((prev) => ({
+          ...prev,
+          [cacheKey]: {
+            ...prev[cacheKey],
+            loading: false,
+            error
+          }
+        }));
+        throw error;
+      }
+    },
+    [effectiveHandlers]
+  );
+  const invalidateProposal = useCallback((proposalId) => {
+    setSharedProposals((prev) => {
+      const updated = { ...prev };
+      Object.keys(updated).forEach((key) => {
+        if (key.endsWith(`:${proposalId}`)) {
+          updated[key] = {
+            ...updated[key],
+            lastFetched: 0
+            // Mark as stale
+          };
+        }
+      });
+      return updated;
+    });
+  }, []);
+  const subscribeToProposal = useCallback(
+    (cacheKey) => {
+      return sharedProposals[cacheKey]?.proposal;
+    },
+    [sharedProposals]
+  );
+  const openDrawer = useCallback((id, content) => {
+    setActiveDrawerId(id);
+    setDrawerContent(content);
+  }, []);
+  const closeDrawer = useCallback(() => {
+    setActiveDrawerId(null);
+    setDrawerContent(null);
+  }, []);
+  return /* @__PURE__ */ React.createElement(
+    BlocknoteContext.Provider,
+    {
+      value: {
+        editor,
+        handlers: effectiveHandlers,
+        blockRequirements,
+        editable,
+        docType,
+        flowVersion,
+        sharedProposals,
+        fetchSharedProposal,
+        invalidateProposal,
+        subscribeToProposal,
+        activeDrawerId,
+        drawerContent,
+        openDrawer,
+        closeDrawer,
+        visualizationRenderer,
+        getDynamicListData,
+        dynamicListPanelRenderer,
+        dynamicListRenderer,
+        domainCardRenderer,
+        onFlowStepRefClick,
+        mapConfig,
+        connectedUsers,
+        awarenessInstance,
+        translate,
+        topicActionRuntime
+      }
+    },
+    children
+  );
+};
+var useBlocknoteContext = () => {
+  const context = useContext(BlocknoteContext);
+  if (!context) {
+    throw new Error("useBlocknoteContext must be used within a BlocknoteProvider");
+  }
+  return context;
+};
+var useBlocknoteHandlers = () => {
+  const { handlers } = useBlocknoteContext();
+  if (!handlers) {
+    throw new Error("BlocknoteHandlers not provided to BlocknoteContext");
+  }
+  return handlers;
+};
+var useTranslate = () => {
+  const { translate } = useBlocknoteContext();
+  const translateRef = useRef(translate);
+  useEffect(() => {
+    translateRef.current = translate;
+  }, [translate]);
+  return useCallback((key, opts) => {
+    const fn = translateRef.current;
+    if (fn) return fn(key, opts);
+    return opts?.defaultValue ?? key;
+  }, []);
+};
+
+// src/mantine/blocks/hooks/hookedActions/useHookedActions.ts
+function useHookedActions({ block, editor }) {
+  const handlers = useBlocknoteHandlers();
+  const handlersRef = useRef2(handlers);
+  const editorRef = useRef2(editor);
+  const blockRef = useRef2(block);
+  useEffect2(() => {
+    handlersRef.current = handlers;
+  }, [handlers]);
+  useEffect2(() => {
+    editorRef.current = editor;
+  }, [editor]);
+  useEffect2(() => {
+    blockRef.current = block;
+  }, [block]);
+  const executeHookedActions = useCallback2((actionId, payload) => {
+    const currentBlock = blockRef.current;
+    const hookedActionsConfig = parseHookedActionsConfig(currentBlock.props?.hookedActions || "");
+    const actionsForEvent = hookedActionsConfig[actionId] || [];
+    if (actionsForEvent.length === 0) {
+      return;
+    }
+    actionsForEvent.forEach((actionInstance) => {
+      if (!actionInstance.enabled) {
+        return;
+      }
+      const actionType = getHookedActionType(actionInstance.type);
+      if (!actionType) {
+        console.warn(`Unknown hooked action type: ${actionInstance.type}`);
+        return;
+      }
+      actionType.execute(actionInstance, payload, {
+        handlers: handlersRef.current,
+        editor: editorRef.current,
+        sourceBlock: currentBlock
+      }).catch((error) => {
+        console.error(`Hooked action ${actionInstance.type} failed:`, error);
+      });
+    });
+  }, []);
+  const executeHookedActionsWithResults = useCallback2(async (actionId, payload) => {
+    const currentBlock = blockRef.current;
+    const hookedActionsConfig = parseHookedActionsConfig(currentBlock.props?.hookedActions || "");
+    const actionsForEvent = hookedActionsConfig[actionId] || [];
+    const errors = [];
+    let executed = 0;
+    for (const actionInstance of actionsForEvent) {
+      if (!actionInstance.enabled) {
+        continue;
+      }
+      const actionType = getHookedActionType(actionInstance.type);
+      if (!actionType) {
+        errors.push(`Unknown hooked action type: ${actionInstance.type}`);
+        continue;
+      }
+      try {
+        await actionType.execute(actionInstance, payload, {
+          handlers: handlersRef.current,
+          editor: editorRef.current,
+          sourceBlock: currentBlock
+        });
+        executed++;
+      } catch (error) {
+        errors.push(`${actionInstance.type}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    return { executed, errors };
+  }, []);
+  return {
+    executeHookedActions,
+    executeHookedActionsWithResults
+  };
+}
+
+export {
+  registerHookedActionType,
+  getHookedActionType,
+  getAllHookedActionTypes,
+  registerBlockActions,
+  getBlockActions,
+  parseHookedActionsConfig,
+  stringifyHookedActionsConfig,
+  createHookedActionInstance,
+  useHookedActions,
+  registerBuiltInActionTypes,
+  governanceGroupActions,
+  initializeHookedActions,
+  getHandlersFromEditor,
+  mergeBlocknoteHandlers,
+  BlocknoteProvider,
+  useBlocknoteContext,
+  useBlocknoteHandlers,
+  useTranslate
+};
+//# sourceMappingURL=chunk-4DGCCXD6.js.map