@uipath/apollo-react 6.27.0 → 6.29.0

package/dist/canvas/components/BaseCanvas/index.cjs

@@ -82,6 +82,7 @@ var __webpack_exports__ = {};
         useAutoLayout: ()=>_BaseCanvas_hooks__rspack_import_2.useAutoLayout,
         useEnsureNodesInView: ()=>_BaseCanvas_hooks__rspack_import_2.useEnsureNodesInView,
         useFitView: ()=>_BaseCanvas_hooks__rspack_import_2.useFitView,
+        useIsConnectionReadOnly: ()=>_ReadOnlyNodesContext__rspack_import_9.useIsConnectionReadOnly,
         useIsNodeReadOnly: ()=>_ReadOnlyNodesContext__rspack_import_9.useIsNodeReadOnly,
         useMaintainNodesInView: ()=>_BaseCanvas_hooks__rspack_import_2.useMaintainNodesInView
     });
@@ -89,99 +90,107 @@ var __webpack_exports__ = {};
     var _BaseCanvas_constants__rspack_import_1 = __webpack_require__("./BaseCanvas.constants");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _BaseCanvas_constants__rspack_import_1)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_BaseCanvas_constants__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _BaseCanvas_hooks__rspack_import_2 = __webpack_require__("./BaseCanvas.hooks");
     var _BaseCanvas_types__rspack_import_3 = __webpack_require__("./BaseCanvas.types");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _BaseCanvas_types__rspack_import_3)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_BaseCanvas_types__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _BaseCanvasModeProvider__rspack_import_4 = __webpack_require__("./BaseCanvasModeProvider");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _BaseCanvasModeProvider__rspack_import_4)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_BaseCanvasModeProvider__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _CanvasBackground__rspack_import_5 = __webpack_require__("./CanvasBackground");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _CanvasBackground__rspack_import_5)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_CanvasBackground__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _CanvasProviders__rspack_import_6 = __webpack_require__("./CanvasProviders");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _CanvasProviders__rspack_import_6)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_CanvasProviders__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _CanvasThemeContext__rspack_import_7 = __webpack_require__("./CanvasThemeContext");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _CanvasThemeContext__rspack_import_7)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_CanvasThemeContext__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _ConnectedHandlesContext__rspack_import_8 = __webpack_require__("./ConnectedHandlesContext");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _ConnectedHandlesContext__rspack_import_8)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_ConnectedHandlesContext__rspack_import_8[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     var _ReadOnlyNodesContext__rspack_import_9 = __webpack_require__("./ReadOnlyNodesContext");
     var _SelectionStateContext__rspack_import_10 = __webpack_require__("./SelectionStateContext");
     var __rspack_reexport = {};
     for(const __rspack_import_key in _SelectionStateContext__rspack_import_10)if ([
-        "useAutoLayout",
-        "useMaintainNodesInView",
         "useEnsureNodesInView",
         "default",
+        "useFitView",
+        "useAutoLayout",
+        "useMaintainNodesInView",
         "useIsNodeReadOnly",
-        "BaseCanvas",
-        "useFitView"
+        "useIsConnectionReadOnly",
+        "BaseCanvas"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_SelectionStateContext__rspack_import_10[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
@@ -189,6 +198,7 @@ exports.BaseCanvas = __webpack_exports__.BaseCanvas;
 exports.useAutoLayout = __webpack_exports__.useAutoLayout;
 exports.useEnsureNodesInView = __webpack_exports__.useEnsureNodesInView;
 exports.useFitView = __webpack_exports__.useFitView;
+exports.useIsConnectionReadOnly = __webpack_exports__.useIsConnectionReadOnly;
 exports.useIsNodeReadOnly = __webpack_exports__.useIsNodeReadOnly;
 exports.useMaintainNodesInView = __webpack_exports__.useMaintainNodesInView;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
@@ -196,6 +206,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "useAutoLayout",
     "useEnsureNodesInView",
     "useFitView",
+    "useIsConnectionReadOnly",
     "useIsNodeReadOnly",
     "useMaintainNodesInView"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/canvas/components/BaseCanvas/index.d.ts

@@ -7,6 +7,6 @@ export * from './CanvasBackground';
 export * from './CanvasProviders';
 export * from './CanvasThemeContext';
 export * from './ConnectedHandlesContext';
-export { useIsNodeReadOnly } from './ReadOnlyNodesContext';
+export { useIsConnectionReadOnly, useIsNodeReadOnly } from './ReadOnlyNodesContext';
 export * from './SelectionStateContext';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/components/BaseCanvas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/BaseCanvas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,UAAU,EACV,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/BaseCanvas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,UAAU,EACV,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACpF,cAAc,yBAAyB,CAAC"}

package/dist/canvas/components/BaseCanvas/index.js

@@ -1,6 +1,6 @@
 import { BaseCanvas } from "./BaseCanvas.js";
 import { useAutoLayout, useEnsureNodesInView, useFitView, useMaintainNodesInView } from "./BaseCanvas.hooks.js";
-import { useIsNodeReadOnly } from "./ReadOnlyNodesContext.js";
+import { useIsConnectionReadOnly, useIsNodeReadOnly } from "./ReadOnlyNodesContext.js";
 export * from "./BaseCanvas.constants.js";
 export * from "./BaseCanvas.types.js";
 export * from "./BaseCanvasModeProvider.js";
@@ -9,4 +9,4 @@ export * from "./CanvasProviders.js";
 export * from "./CanvasThemeContext.js";
 export * from "./ConnectedHandlesContext.js";
 export * from "./SelectionStateContext.js";
-export { BaseCanvas, useAutoLayout, useEnsureNodesInView, useFitView, useIsNodeReadOnly, useMaintainNodesInView };
+export { BaseCanvas, useAutoLayout, useEnsureNodesInView, useFitView, useIsConnectionReadOnly, useIsNodeReadOnly, useMaintainNodesInView };

package/dist/canvas/components/BaseCanvas/useReadOnlyConnectionCallbacks.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useReadOnlyConnectionCallbacks: ()=>useReadOnlyConnectionCallbacks
+});
+const external_react_namespaceObject = require("react");
+const useLatestRef_cjs_namespaceObject = require("../../hooks/useLatestRef.cjs");
+const external_ReadOnlyNodesContext_cjs_namespaceObject = require("./ReadOnlyNodesContext.cjs");
+const includesReadOnlyConnection = (readOnlyNodeIds, ...connections)=>connections.some(({ source, target })=>(0, external_ReadOnlyNodesContext_cjs_namespaceObject.isConnectionReadOnly)(readOnlyNodeIds, source, target));
+function useReadOnlyConnectionCallbacks({ readOnlyNodeIds, isValidConnection, onConnect, onReconnect, onReconnectEnd }) {
+    const readOnlyNodeIdsRef = (0, useLatestRef_cjs_namespaceObject.useLatestRef)(readOnlyNodeIds);
+    const isValidConnectionRef = (0, useLatestRef_cjs_namespaceObject.useLatestRef)(isValidConnection);
+    const onConnectRef = (0, useLatestRef_cjs_namespaceObject.useLatestRef)(onConnect);
+    const onReconnectRef = (0, useLatestRef_cjs_namespaceObject.useLatestRef)(onReconnect);
+    const onReconnectEndRef = (0, useLatestRef_cjs_namespaceObject.useLatestRef)(onReconnectEnd);
+    const guardedIsValidConnection = (0, external_react_namespaceObject.useCallback)((connection)=>{
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (includesReadOnlyConnection(currentReadOnlyNodeIds, connection)) return false;
+        return isValidConnectionRef.current?.(connection) ?? true;
+    }, [
+        isValidConnectionRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnConnect = (0, external_react_namespaceObject.useCallback)((connection)=>{
+        const currentOnConnect = onConnectRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnConnect || includesReadOnlyConnection(currentReadOnlyNodeIds, connection)) return;
+        currentOnConnect(connection);
+    }, [
+        onConnectRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnReconnect = (0, external_react_namespaceObject.useCallback)((edgeBeingReconnected, proposedConnection)=>{
+        const currentOnReconnect = onReconnectRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnReconnect || includesReadOnlyConnection(currentReadOnlyNodeIds, edgeBeingReconnected, proposedConnection)) return;
+        currentOnReconnect(edgeBeingReconnected, proposedConnection);
+    }, [
+        onReconnectRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnReconnectEnd = (0, external_react_namespaceObject.useCallback)((event, edgeBeingReconnected, handleType, connectionState)=>{
+        const currentOnReconnectEnd = onReconnectEndRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnReconnectEnd || includesReadOnlyConnection(currentReadOnlyNodeIds, edgeBeingReconnected)) return;
+        currentOnReconnectEnd(event, edgeBeingReconnected, handleType, connectionState);
+    }, [
+        onReconnectEndRef,
+        readOnlyNodeIdsRef
+    ]);
+    return {
+        guardedIsValidConnection,
+        guardedOnConnect: onConnect ? guardedOnConnect : void 0,
+        guardedOnReconnect: onReconnect ? guardedOnReconnect : void 0,
+        guardedOnReconnectEnd: onReconnectEnd ? guardedOnReconnectEnd : void 0
+    };
+}
+exports.useReadOnlyConnectionCallbacks = __webpack_exports__.useReadOnlyConnectionCallbacks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useReadOnlyConnectionCallbacks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/BaseCanvas/useReadOnlyConnectionCallbacks.d.ts

@@ -0,0 +1,13 @@
+import type { Edge, Node, ReactFlowProps } from '../../xyflow/react.ts';
+type ConnectionCallbacks<EdgeType extends Edge> = Pick<ReactFlowProps<Node, EdgeType>, 'isValidConnection' | 'onConnect' | 'onReconnect' | 'onReconnectEnd'>;
+type UseReadOnlyConnectionCallbacksOptions<EdgeType extends Edge> = ConnectionCallbacks<EdgeType> & {
+    readOnlyNodeIds: ReadonlySet<string>;
+};
+export declare function useReadOnlyConnectionCallbacks<EdgeType extends Edge>({ readOnlyNodeIds, isValidConnection, onConnect, onReconnect, onReconnectEnd, }: UseReadOnlyConnectionCallbacksOptions<EdgeType>): {
+    guardedIsValidConnection: import("@xyflow/react").IsValidConnection<EdgeType>;
+    guardedOnConnect: import("@xyflow/system").OnConnect | undefined;
+    guardedOnReconnect: import("@xyflow/system").OnReconnect<EdgeType> | undefined;
+    guardedOnReconnectEnd: ((event: MouseEvent | TouchEvent, edge: EdgeType, handleType: import("@xyflow/system").HandleType, connectionState: import("@xyflow/system").FinalConnectionState) => void) | undefined;
+};
+export {};
+//# sourceMappingURL=useReadOnlyConnectionCallbacks.d.ts.map

package/dist/canvas/components/BaseCanvas/useReadOnlyConnectionCallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadOnlyConnectionCallbacks.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/BaseCanvas/useReadOnlyConnectionCallbacks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,IAAI,EACJ,IAAI,EACJ,cAAc,EACf,MAAM,0CAA0C,CAAC;AAOlD,KAAK,mBAAmB,CAAC,QAAQ,SAAS,IAAI,IAAI,IAAI,CACpD,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,EAC9B,mBAAmB,GAAG,WAAW,GAAG,aAAa,GAAG,gBAAgB,CACrE,CAAC;AAEF,KAAK,qCAAqC,CAAC,QAAQ,SAAS,IAAI,IAC9D,mBAAmB,CAAC,QAAQ,CAAC,GAAG;IAC9B,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC,CAAC;AAQJ,wBAAgB,8BAA8B,CAAC,QAAQ,SAAS,IAAI,EAAE,EACpE,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,cAAc,GACf,EAAE,qCAAqC,CAAC,QAAQ,CAAC;;;;;EAsEjD"}

package/dist/canvas/components/BaseCanvas/useReadOnlyConnectionCallbacks.js

@@ -0,0 +1,53 @@
+import { useCallback } from "react";
+import { useLatestRef } from "../../hooks/useLatestRef.js";
+import { isConnectionReadOnly } from "./ReadOnlyNodesContext.js";
+const includesReadOnlyConnection = (readOnlyNodeIds, ...connections)=>connections.some(({ source, target })=>isConnectionReadOnly(readOnlyNodeIds, source, target));
+function useReadOnlyConnectionCallbacks({ readOnlyNodeIds, isValidConnection, onConnect, onReconnect, onReconnectEnd }) {
+    const readOnlyNodeIdsRef = useLatestRef(readOnlyNodeIds);
+    const isValidConnectionRef = useLatestRef(isValidConnection);
+    const onConnectRef = useLatestRef(onConnect);
+    const onReconnectRef = useLatestRef(onReconnect);
+    const onReconnectEndRef = useLatestRef(onReconnectEnd);
+    const guardedIsValidConnection = useCallback((connection)=>{
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (includesReadOnlyConnection(currentReadOnlyNodeIds, connection)) return false;
+        return isValidConnectionRef.current?.(connection) ?? true;
+    }, [
+        isValidConnectionRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnConnect = useCallback((connection)=>{
+        const currentOnConnect = onConnectRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnConnect || includesReadOnlyConnection(currentReadOnlyNodeIds, connection)) return;
+        currentOnConnect(connection);
+    }, [
+        onConnectRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnReconnect = useCallback((edgeBeingReconnected, proposedConnection)=>{
+        const currentOnReconnect = onReconnectRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnReconnect || includesReadOnlyConnection(currentReadOnlyNodeIds, edgeBeingReconnected, proposedConnection)) return;
+        currentOnReconnect(edgeBeingReconnected, proposedConnection);
+    }, [
+        onReconnectRef,
+        readOnlyNodeIdsRef
+    ]);
+    const guardedOnReconnectEnd = useCallback((event, edgeBeingReconnected, handleType, connectionState)=>{
+        const currentOnReconnectEnd = onReconnectEndRef.current;
+        const currentReadOnlyNodeIds = readOnlyNodeIdsRef.current;
+        if (!currentOnReconnectEnd || includesReadOnlyConnection(currentReadOnlyNodeIds, edgeBeingReconnected)) return;
+        currentOnReconnectEnd(event, edgeBeingReconnected, handleType, connectionState);
+    }, [
+        onReconnectEndRef,
+        readOnlyNodeIdsRef
+    ]);
+    return {
+        guardedIsValidConnection,
+        guardedOnConnect: onConnect ? guardedOnConnect : void 0,
+        guardedOnReconnect: onReconnect ? guardedOnReconnect : void 0,
+        guardedOnReconnectEnd: onReconnectEnd ? guardedOnReconnectEnd : void 0
+    };
+}
+export { useReadOnlyConnectionCallbacks };

package/dist/canvas/components/CaseFlow/case-flow.manifest.d.ts

@@ -97,6 +97,7 @@ export declare const caseFlowManifest: {
                     requiresPermissions?: string[] | undefined;
                     hideOnExecution?: boolean | undefined;
                     nodeTypes?: string[] | undefined;
+                    shapes?: ("square" | "circle" | "container" | "rectangle")[] | undefined;
                     handles?: {
                         handleType: "input" | "output" | "artifact";
                         type?: "target" | "source" | undefined;
@@ -112,6 +113,7 @@ export declare const caseFlowManifest: {
                     requiresPermissions?: string[] | undefined;
                     hideOnExecution?: boolean | undefined;
                     nodeTypes?: string[] | undefined;
+                    shapes?: ("square" | "circle" | "container" | "rectangle")[] | undefined;
                     handles?: {
                         handleType: "input" | "output" | "artifact";
                         type?: "target" | "source" | undefined;

package/dist/canvas/components/CaseFlow/case-flow.manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"case-flow.manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/CaseFlow/case-flow.manifest.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAMnF,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,EAUhD,CAAC;AAMF,eAAO,MAAM,6BAA6B,EAAE,YA2D3C,CAAC;AAMF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI5B,CAAC"}
+{"version":3,"file":"case-flow.manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/CaseFlow/case-flow.manifest.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAMnF,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,EAUhD,CAAC;AAMF,eAAO,MAAM,6BAA6B,EAAE,YA2D3C,CAAC;AAMF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI5B,CAAC"}

package/dist/canvas/components/Toolbar/EdgeToolbar/useEdgeToolbarState.cjs

@@ -33,13 +33,20 @@ const useCanvasNodeLayout_cjs_namespaceObject = require("../../../hooks/useCanva
 const createPreviewGraph_cjs_namespaceObject = require("../../../utils/createPreviewGraph.cjs");
 const createPreviewNode_cjs_namespaceObject = require("../../../utils/createPreviewNode.cjs");
 const BaseCanvasModeProvider_cjs_namespaceObject = require("../../BaseCanvas/BaseCanvasModeProvider.cjs");
+const ReadOnlyNodesContext_cjs_namespaceObject = require("../../BaseCanvas/ReadOnlyNodesContext.cjs");
 const LoopNode_helpers_cjs_namespaceObject = require("../../LoopNode/LoopNode.helpers.cjs");
 const external_useEdgeToolbarPositioning_cjs_namespaceObject = require("./useEdgeToolbarPositioning.cjs");
+function hasSameConnection(edge, expected) {
+    if (!edge) return false;
+    return edge.source === expected.source && edge.target === expected.target && (edge.sourceHandle ?? null) === (expected.sourceHandle ?? null) && (edge.targetHandle ?? null) === (expected.targetHandle ?? null);
+}
 function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target, sourceHandleId, targetHandleId, sourcePosition, targetPosition, ignoredNodeTypes }) {
     const reactFlow = (0, react_cjs_namespaceObject.useReactFlow)();
     const { getManifestForNode } = (0, useCanvasNodeLayout_cjs_namespaceObject.useCanvasNodeLayout)();
     const { mode } = (0, BaseCanvasModeProvider_cjs_namespaceObject.useBaseCanvasMode)();
     const isDesignMode = 'design' === mode;
+    const isFrozenConnection = (0, ReadOnlyNodesContext_cjs_namespaceObject.useIsConnectionReadOnly)(source, target);
+    const isConnectionReadOnlyNow = (0, ReadOnlyNodesContext_cjs_namespaceObject.useReadOnlyConnectionCheck)();
     const previewEdge = (0, createPreviewNode_cjs_namespaceObject.isPreviewEdge)({
         id: edgeId,
         source,
@@ -52,7 +59,12 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
     });
     const handleAddNodeOnEdge = (0, external_react_namespaceObject.useCallback)((position)=>{
         const originalEdge = reactFlow.getEdges().find((edge)=>edge.id === edgeId);
-        if (!originalEdge) return;
+        if (!hasSameConnection(originalEdge, {
+            source,
+            sourceHandle: sourceHandleId,
+            target,
+            targetHandle: targetHandleId
+        }) || isConnectionReadOnlyNow(originalEdge.source, originalEdge.target)) return;
         const sourceEndpoint = {
             nodeId: source,
             handleId: sourceHandleId ?? external_constants_cjs_namespaceObject.DEFAULT_SOURCE_HANDLE_ID
@@ -80,6 +92,11 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
                 handleId: targetHandleId
             },
             ...containerOverrides ?? {}
+        }, {
+            canApply: (edges)=>{
+                const currentEdge = edges.find((edge)=>edge.id === edgeId);
+                return hasSameConnection(currentEdge, originalEdge) && !isConnectionReadOnlyNow(currentEdge.source, currentEdge.target);
+            }
         });
     }, [
         sourcePosition,
@@ -90,7 +107,8 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
         target,
         targetHandleId,
         edgeId,
-        ignoredNodeTypes
+        ignoredNodeTypes,
+        isConnectionReadOnlyNow
     ]);
     const config = (0, external_react_namespaceObject.useMemo)(()=>({
             actions: [
@@ -107,7 +125,7 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
         }), [
         handleAddNodeOnEdge
     ]);
-    const showToolbar = isHovered && isDesignMode && null !== positionData && !previewEdge;
+    const showToolbar = isHovered && isDesignMode && null !== positionData && !previewEdge && !isFrozenConnection;
     return {
         showToolbar,
         toolbarPositioning: positionData,

package/dist/canvas/components/Toolbar/EdgeToolbar/useEdgeToolbarState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEdgeToolbarState.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Toolbar/EdgeToolbar/useEdgeToolbarState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,0CAA0C,CAAC;AAQvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGtF,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,kBAAkB,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACnD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,qBAAqB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;CAC3D;AAED,wBAAgB,mBAAmB,CAAC,EAClC,MAAM,EACN,cAAc,EACd,SAAS,EACT,MAAM,EACN,MAAM,EACN,cAAc,EACd,cAAc,EACd,cAAc,EACd,cAAc,EACd,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,gBAAgB,CAyF7C"}
+{"version":3,"file":"useEdgeToolbarState.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Toolbar/EdgeToolbar/useEdgeToolbarState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,QAAQ,EAAgB,MAAM,0CAA0C,CAAC;AAYlG,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGtF,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,kBAAkB,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACnD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,qBAAqB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;CAC3D;AAiBD,wBAAgB,mBAAmB,CAAC,EAClC,MAAM,EACN,cAAc,EACd,SAAS,EACT,MAAM,EACN,MAAM,EACN,cAAc,EACd,cAAc,EACd,cAAc,EACd,cAAc,EACd,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,gBAAgB,CAmH7C"}

package/dist/canvas/components/Toolbar/EdgeToolbar/useEdgeToolbarState.js

@@ -5,13 +5,20 @@ import { useCanvasNodeLayout } from "../../../hooks/useCanvasNodeLayout.js";
 import { showPreviewGraph } from "../../../utils/createPreviewGraph.js";
 import { isPreviewEdge } from "../../../utils/createPreviewNode.js";
 import { useBaseCanvasMode } from "../../BaseCanvas/BaseCanvasModeProvider.js";
+import { useIsConnectionReadOnly, useReadOnlyConnectionCheck } from "../../BaseCanvas/ReadOnlyNodesContext.js";
 import { resolveContainerAddNodePreview } from "../../LoopNode/LoopNode.helpers.js";
 import { useEdgeToolbarPositioning } from "./useEdgeToolbarPositioning.js";
+function hasSameConnection(edge, expected) {
+    if (!edge) return false;
+    return edge.source === expected.source && edge.target === expected.target && (edge.sourceHandle ?? null) === (expected.sourceHandle ?? null) && (edge.targetHandle ?? null) === (expected.targetHandle ?? null);
+}
 function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target, sourceHandleId, targetHandleId, sourcePosition, targetPosition, ignoredNodeTypes }) {
     const reactFlow = useReactFlow();
     const { getManifestForNode } = useCanvasNodeLayout();
     const { mode } = useBaseCanvasMode();
     const isDesignMode = 'design' === mode;
+    const isFrozenConnection = useIsConnectionReadOnly(source, target);
+    const isConnectionReadOnlyNow = useReadOnlyConnectionCheck();
     const previewEdge = isPreviewEdge({
         id: edgeId,
         source,
@@ -24,7 +31,12 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
     });
     const handleAddNodeOnEdge = useCallback((position)=>{
         const originalEdge = reactFlow.getEdges().find((edge)=>edge.id === edgeId);
-        if (!originalEdge) return;
+        if (!hasSameConnection(originalEdge, {
+            source,
+            sourceHandle: sourceHandleId,
+            target,
+            targetHandle: targetHandleId
+        }) || isConnectionReadOnlyNow(originalEdge.source, originalEdge.target)) return;
         const sourceEndpoint = {
             nodeId: source,
             handleId: sourceHandleId ?? DEFAULT_SOURCE_HANDLE_ID
@@ -52,6 +64,11 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
                 handleId: targetHandleId
             },
             ...containerOverrides ?? {}
+        }, {
+            canApply: (edges)=>{
+                const currentEdge = edges.find((edge)=>edge.id === edgeId);
+                return hasSameConnection(currentEdge, originalEdge) && !isConnectionReadOnlyNow(currentEdge.source, currentEdge.target);
+            }
         });
     }, [
         sourcePosition,
@@ -62,7 +79,8 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
         target,
         targetHandleId,
         edgeId,
-        ignoredNodeTypes
+        ignoredNodeTypes,
+        isConnectionReadOnlyNow
     ]);
     const config = useMemo(()=>({
             actions: [
@@ -79,7 +97,7 @@ function useEdgeToolbarState({ edgeId, pathElementRef, isHovered, source, target
         }), [
         handleAddNodeOnEdge
     ]);
-    const showToolbar = isHovered && isDesignMode && null !== positionData && !previewEdge;
+    const showToolbar = isHovered && isDesignMode && null !== positionData && !previewEdge && !isFrozenConnection;
     return {
         showToolbar,
         toolbarPositioning: positionData,

package/dist/canvas/schema/node-definition/index.cjs

@@ -28,7 +28,7 @@ __webpack_require__.d(__webpack_exports__, {
     nodeDisplayManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeDisplayManifestSchema,
     handleGroupOverrideSchema: ()=>external_handle_cjs_namespaceObject.handleGroupOverrideSchema,
     handlePositionSchema: ()=>external_handle_cjs_namespaceObject.handlePositionSchema,
-    nodeShapeSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeShapeSchema,
+    nodeShapeSchema: ()=>external_shape_cjs_namespaceObject.nodeShapeSchema,
     nodeManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeManifestSchema,
     nodeRuntimeConstraintsManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeRuntimeConstraintsManifestSchema,
     handleTypeSchema: ()=>external_handle_cjs_namespaceObject.handleTypeSchema,
@@ -40,6 +40,7 @@ __webpack_require__.d(__webpack_exports__, {
 const external_category_manifest_cjs_namespaceObject = require("./category-manifest.cjs");
 const external_handle_cjs_namespaceObject = require("./handle.cjs");
 const external_node_manifest_cjs_namespaceObject = require("./node-manifest.cjs");
+const external_shape_cjs_namespaceObject = require("./shape.cjs");
 exports.categoryManifestSchema = __webpack_exports__.categoryManifestSchema;
 exports.handleBoundarySchema = __webpack_exports__.handleBoundarySchema;
 exports.handleGroupManifestSchema = __webpack_exports__.handleGroupManifestSchema;

package/dist/canvas/schema/node-definition/index.d.ts

@@ -3,6 +3,8 @@ export { categoryManifestSchema } from './category-manifest';
 export type { ConnectionConstraint, HandleTarget } from './constraints';
 export type { HandleBoundary, HandleCategory, HandleGroupManifest, HandleGroupOverride, HandleManifest, HandlePosition, HandleType, } from './handle';
 export { handleBoundarySchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema, } from './handle';
-export type { NodeDisplayManifest, NodeManifest, NodeShape, RuntimeConstraints, } from './node-manifest';
-export { nodeDisplayManifestSchema, nodeManifestSchema, nodeRuntimeConstraintsManifestSchema, nodeShapeSchema, } from './node-manifest';
+export type { NodeDisplayManifest, NodeManifest, RuntimeConstraints, } from './node-manifest';
+export { nodeDisplayManifestSchema, nodeManifestSchema, nodeRuntimeConstraintsManifestSchema, } from './node-manifest';
+export type { NodeShape } from './shape';
+export { nodeShapeSchema } from './shape';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/node-definition/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAExE,YAAY,EACV,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,SAAS,EACT,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,oCAAoC,EACpC,eAAe,GAChB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAExE,YAAY,EACV,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,oCAAoC,GACrC,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/canvas/schema/node-definition/index.js

@@ -1,4 +1,5 @@
 import { categoryManifestSchema } from "./category-manifest.js";
 import { handleBoundarySchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema } from "./handle.js";
-import { nodeDisplayManifestSchema, nodeManifestSchema, nodeRuntimeConstraintsManifestSchema, nodeShapeSchema } from "./node-manifest.js";
+import { nodeDisplayManifestSchema, nodeManifestSchema, nodeRuntimeConstraintsManifestSchema } from "./node-manifest.js";
+import { nodeShapeSchema } from "./shape.js";
 export { categoryManifestSchema, handleBoundarySchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema, nodeDisplayManifestSchema, nodeManifestSchema, nodeRuntimeConstraintsManifestSchema, nodeShapeSchema };

package/dist/canvas/schema/node-definition/node-manifest.cjs

@@ -27,18 +27,12 @@ __webpack_require__.d(__webpack_exports__, {
     nodeManifestSchema: ()=>nodeManifestSchema,
     nodeRuntimeConstraintsManifestSchema: ()=>nodeRuntimeConstraintsManifestSchema,
     nodeDisplayManifestSchema: ()=>nodeDisplayManifestSchema,
-    nodeDebugManifestSchema: ()=>nodeDebugManifestSchema,
-    nodeShapeSchema: ()=>nodeShapeSchema
+    nodeDebugManifestSchema: ()=>nodeDebugManifestSchema
 });
 const external_zod_namespaceObject = require("zod");
 const external_toolbar_cjs_namespaceObject = require("../toolbar.cjs");
 const external_handle_cjs_namespaceObject = require("./handle.cjs");
-const nodeShapeSchema = external_zod_namespaceObject.z["enum"]([
-    'circle',
-    'square',
-    'rectangle',
-    'container'
-]);
+const external_shape_cjs_namespaceObject = require("./shape.cjs");
 const nodeDebugManifestSchema = external_zod_namespaceObject.z.object({
     runtime: external_zod_namespaceObject.z.string().min(1)
 });
@@ -47,7 +41,7 @@ const nodeDisplayManifestSchema = external_zod_namespaceObject.z.object({
     canvasLabel: external_zod_namespaceObject.z.string().min(1).optional(),
     description: external_zod_namespaceObject.z.string().optional(),
     icon: external_zod_namespaceObject.z.string().min(1).optional(),
-    shape: nodeShapeSchema.optional(),
+    shape: external_shape_cjs_namespaceObject.nodeShapeSchema.optional(),
     color: external_zod_namespaceObject.z.string().optional(),
     background: external_zod_namespaceObject.z.string().optional(),
     iconBackground: external_zod_namespaceObject.z.string().optional(),
@@ -89,13 +83,11 @@ exports.nodeDebugManifestSchema = __webpack_exports__.nodeDebugManifestSchema;
 exports.nodeDisplayManifestSchema = __webpack_exports__.nodeDisplayManifestSchema;
 exports.nodeManifestSchema = __webpack_exports__.nodeManifestSchema;
 exports.nodeRuntimeConstraintsManifestSchema = __webpack_exports__.nodeRuntimeConstraintsManifestSchema;
-exports.nodeShapeSchema = __webpack_exports__.nodeShapeSchema;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "nodeDebugManifestSchema",
     "nodeDisplayManifestSchema",
     "nodeManifestSchema",
-    "nodeRuntimeConstraintsManifestSchema",
-    "nodeShapeSchema"
+    "nodeRuntimeConstraintsManifestSchema"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true