@uipath/apollo-react 4.13.0-pr556.e4e2855 → 4.13.0

package/dist/canvas/core/NodeTypeRegistry.js

@@ -4,24 +4,12 @@ import { CategoryTreeAdapter } from "./CategoryTreeAdapter.js";
 class NodeTypeRegistry {
     categoryById = new Map();
     nodeByType = new Map();
-    nodeByTypeVersion = new Map();
     nodeHandles = new Map();
-    nodeHandlesByTypeVersion = new Map();
     categoriesByParent = new Map();
     nodesByCategory = new Map();
     categoryAncestors = new Map();
     categoryDescendants = new Map();
     categoryTree = null;
-    getNodeHandles(manifest) {
-        return manifest.handleConfiguration.flatMap((hc)=>hc.handles).reduce((acc, handle)=>{
-            if (!acc[handle.type]) acc[handle.type] = [];
-            acc[handle.type]?.push(handle);
-            return acc;
-        }, {});
-    }
-    getTypeVersionKey(nodeType, version) {
-        return `${nodeType}:${version}`;
-    }
     registerNodeManifests(nodes) {
         const categoryMap = new Map();
         for (const node of nodes){
@@ -43,18 +31,18 @@ class NodeTypeRegistry {
                 c.id,
                 c
             ]));
-        this.nodeByType = new Map();
-        this.nodeByTypeVersion = new Map();
-        this.nodeHandles = new Map();
-        this.nodeHandlesByTypeVersion = new Map();
-        for (const nodeManifest of nodeManifests){
-            const nodeHandles = this.getNodeHandles(nodeManifest);
-            this.nodeByTypeVersion.set(this.getTypeVersionKey(nodeManifest.nodeType, nodeManifest.version), nodeManifest);
-            this.nodeHandlesByTypeVersion.set(this.getTypeVersionKey(nodeManifest.nodeType, nodeManifest.version), nodeHandles);
-            this.nodeByType.set(nodeManifest.nodeType, nodeManifest);
-            this.nodeHandles.set(nodeManifest.nodeType, nodeHandles);
-        }
-        const defaultNodeManifests = Array.from(this.nodeByType.values());
+        this.nodeByType = new Map(nodeManifests.map((n)=>[
+                n.nodeType,
+                n
+            ]));
+        this.nodeHandles = new Map(nodeManifests.map((n)=>[
+                n.nodeType,
+                n.handleConfiguration.flatMap((hc)=>hc.handles).reduce((acc, handle)=>{
+                    if (!acc[handle.type]) acc[handle.type] = [];
+                    acc[handle.type]?.push(handle);
+                    return acc;
+                }, {})
+            ]));
         this.categoriesByParent = new Map();
         for (const cat of categoryManifests){
             const siblings = this.categoriesByParent.get(cat.parentId) ?? [];
@@ -88,17 +76,16 @@ class NodeTypeRegistry {
             this.categoryDescendants.set(cat.id, descendants);
         }
         this.nodesByCategory = new Map();
-        for (const node of defaultNodeManifests){
+        for (const node of nodeManifests){
             const categoryKey = node.category ?? void 0;
             const nodes = this.nodesByCategory.get(categoryKey) ?? [];
             nodes.push(node);
             this.nodesByCategory.set(categoryKey, nodes);
         }
-        this.categoryTree = new CategoryTree(categoryManifests, defaultNodeManifests);
+        this.categoryTree = new CategoryTree(categoryManifests, nodeManifests);
     }
-    getManifest(nodeType, version) {
-        if (!version) return this.nodeByType.get(nodeType);
-        return this.nodeByTypeVersion.get(this.getTypeVersionKey(nodeType, version));
+    getManifest(nodeType) {
+        return this.nodeByType.get(nodeType);
     }
     getAllManifests() {
         return Array.from(this.nodeByType.values());
@@ -109,19 +96,18 @@ class NodeTypeRegistry {
     getAllNodeTypes() {
         return Array.from(this.nodeByType.keys());
     }
-    getHandlesByNodeType(nodeType, version) {
-        if (!version) return this.nodeHandles.get(nodeType) ?? {};
-        return this.nodeHandlesByTypeVersion.get(this.getTypeVersionKey(nodeType, version)) ?? {};
+    getHandlesByNodeType(nodeType) {
+        return this.nodeHandles.get(nodeType) ?? {};
     }
-    getDefaultHandle(nodeType, handleType, version) {
-        const handles = this.getHandlesByNodeType(nodeType, version)[handleType];
+    getDefaultHandle(nodeType, handleType) {
+        const handles = this.nodeHandles.get(nodeType)?.[handleType];
         return handles?.find((h)=>h.isDefaultForType) ?? handles?.[0];
     }
-    createDefaultData(nodeType, label, version) {
-        const manifest = this.getManifest(nodeType, version);
+    createDefaultData(nodeType, label) {
+        const manifest = this.getManifest(nodeType);
         if (!manifest) return {
             nodeType,
-            version: version ?? '1.0.0',
+            version: '1.0.0',
             display: {
                 label: label || nodeType
             }
@@ -148,9 +134,7 @@ class NodeTypeRegistry {
     clear() {
         this.nodesByCategory.clear();
         this.nodeHandles.clear();
-        this.nodeHandlesByTypeVersion.clear();
         this.nodeByType.clear();
-        this.nodeByTypeVersion.clear();
         this.categoryById.clear();
         this.categoryAncestors.clear();
         this.categoryDescendants.clear();

package/dist/canvas/core/useNodeTypeRegistry.cjs

@@ -47,12 +47,11 @@ const useNodeManifests = ()=>{
         registry
     ]);
 };
-const useNodeManifest = (nodeType, version)=>{
+const useNodeManifest = (nodeType)=>{
     const registry = useNodeTypeRegistry();
-    return (0, external_react_namespaceObject.useMemo)(()=>registry.getManifest(nodeType, version), [
+    return (0, external_react_namespaceObject.useMemo)(()=>registry.getManifest(nodeType), [
         registry,
-        nodeType,
-        version
+        nodeType
     ]);
 };
 exports.NodeRegistryContext = __webpack_exports__.NodeRegistryContext;

package/dist/canvas/core/useNodeTypeRegistry.d.ts

@@ -7,6 +7,6 @@ export declare const NodeRegistryContext: import("react").Context<NodeRegistryCo
 export declare const useNodeTypeRegistry: () => NodeTypeRegistry;
 export declare const useOptionalNodeTypeRegistry: () => NodeTypeRegistry | null;
 export declare const useNodeManifests: () => NodeManifest[];
-export declare const useNodeManifest: (nodeType: string, version?: string) => NodeManifest | undefined;
+export declare const useNodeManifest: (nodeType: string) => NodeManifest | undefined;
 export {};
 //# sourceMappingURL=useNodeTypeRegistry.d.ts.map

package/dist/canvas/core/useNodeTypeRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNodeTypeRegistry.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/useNodeTypeRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,UAAU,wBAAwB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,eAAO,MAAM,mBAAmB,0DAAuD,CAAC;AAOxF,eAAO,MAAM,mBAAmB,QAAO,gBAMtC,CAAC;AAMF,eAAO,MAAM,2BAA2B,QAAO,gBAAgB,GAAG,IAGjE,CAAC;AAMF,eAAO,MAAM,gBAAgB,QAAO,YAAY,EAG/C,CAAC;AAOF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,EAAE,UAAU,MAAM,KAAG,YAAY,GAAG,SAGnF,CAAC"}
+{"version":3,"file":"useNodeTypeRegistry.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/useNodeTypeRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,UAAU,wBAAwB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,eAAO,MAAM,mBAAmB,0DAAuD,CAAC;AAOxF,eAAO,MAAM,mBAAmB,QAAO,gBAMtC,CAAC;AAMF,eAAO,MAAM,2BAA2B,QAAO,gBAAgB,GAAG,IAGjE,CAAC;AAMF,eAAO,MAAM,gBAAgB,QAAO,YAAY,EAG/C,CAAC;AAOF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,YAAY,GAAG,SAGjE,CAAC"}

package/dist/canvas/core/useNodeTypeRegistry.js

@@ -15,12 +15,11 @@ const useNodeManifests = ()=>{
         registry
     ]);
 };
-const useNodeManifest = (nodeType, version)=>{
+const useNodeManifest = (nodeType)=>{
     const registry = useNodeTypeRegistry();
-    return useMemo(()=>registry.getManifest(nodeType, version), [
+    return useMemo(()=>registry.getManifest(nodeType), [
         registry,
-        nodeType,
-        version
+        nodeType
     ]);
 };
 export { NodeRegistryContext, useNodeManifest, useNodeManifests, useNodeTypeRegistry, useOptionalNodeTypeRegistry };

package/dist/canvas/hooks/useAddNodeOnConnectEnd.cjs

@@ -28,7 +28,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const react_cjs_namespaceObject = require("../xyflow/react.cjs");
 const external_react_namespaceObject = require("react");
-const createPreviewGraph_cjs_namespaceObject = require("../utils/createPreviewGraph.cjs");
+const index_cjs_namespaceObject = require("../utils/index.cjs");
 const EMPTY_IGNORED_NODE_TYPES = [];
 function useAddNodeOnConnectEnd(ignoredNodeTypes = EMPTY_IGNORED_NODE_TYPES) {
     const reactFlowInstance = (0, react_cjs_namespaceObject.useReactFlow)();
@@ -56,15 +56,8 @@ function useAddNodeOnConnectEnd(ignoredNodeTypes = EMPTY_IGNORED_NODE_TYPES) {
             x: clientX,
             y: clientY
         });
-        (0, createPreviewGraph_cjs_namespaceObject.showPreviewGraph)({
-            sourceNodeId: connectionState.fromNode.id,
-            sourceHandleId: connectionState.fromHandle.id ?? 'output',
-            reactFlowInstance,
-            handlePosition: connectionState.fromHandle.position,
-            sourceHandleType: connectionState.fromHandle.type,
-            ignoredNodeTypes,
-            position: flowDropPosition
-        });
+        const preview = (0, index_cjs_namespaceObject.createPreviewNode)(connectionState.fromNode.id, connectionState.fromHandle.id ?? 'output', reactFlowInstance, flowDropPosition, void 0, connectionState.fromHandle.type, void 0, connectionState.fromHandle.position, ignoredNodeTypes);
+        if (preview) (0, index_cjs_namespaceObject.applyPreviewToReactFlow)(preview, reactFlowInstance);
     }, [
         reactFlowInstance,
         ignoredNodeTypes

package/dist/canvas/hooks/useAddNodeOnConnectEnd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAddNodeOnConnectEnd.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/useAddNodeOnConnectEnd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,0CAA0C,CAAC;AAW3F,wBAAgB,sBAAsB,CAAC,gBAAgB,GAAE,MAAM,EAA6B,gBAoD3F"}
+{"version":3,"file":"useAddNodeOnConnectEnd.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/useAddNodeOnConnectEnd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,0CAA0C,CAAC;AAW3F,wBAAgB,sBAAsB,CAAC,gBAAgB,GAAE,MAAM,EAA6B,gBAyD3F"}

package/dist/canvas/hooks/useAddNodeOnConnectEnd.js

@@ -1,6 +1,6 @@
 import { useReactFlow } from "../xyflow/react.js";
 import { useCallback } from "react";
-import { showPreviewGraph } from "../utils/createPreviewGraph.js";
+import { applyPreviewToReactFlow, createPreviewNode } from "../utils/index.js";
 const EMPTY_IGNORED_NODE_TYPES = [];
 function useAddNodeOnConnectEnd(ignoredNodeTypes = EMPTY_IGNORED_NODE_TYPES) {
     const reactFlowInstance = useReactFlow();
@@ -28,15 +28,8 @@ function useAddNodeOnConnectEnd(ignoredNodeTypes = EMPTY_IGNORED_NODE_TYPES) {
             x: clientX,
             y: clientY
         });
-        showPreviewGraph({
-            sourceNodeId: connectionState.fromNode.id,
-            sourceHandleId: connectionState.fromHandle.id ?? 'output',
-            reactFlowInstance,
-            handlePosition: connectionState.fromHandle.position,
-            sourceHandleType: connectionState.fromHandle.type,
-            ignoredNodeTypes,
-            position: flowDropPosition
-        });
+        const preview = createPreviewNode(connectionState.fromNode.id, connectionState.fromHandle.id ?? 'output', reactFlowInstance, flowDropPosition, void 0, connectionState.fromHandle.type, void 0, connectionState.fromHandle.position, ignoredNodeTypes);
+        if (preview) applyPreviewToReactFlow(preview, reactFlowInstance);
     }, [
         reactFlowInstance,
         ignoredNodeTypes

package/dist/canvas/hooks/usePreviewNode.cjs

@@ -53,10 +53,8 @@ const usePreviewNode = ()=>{
         const connections = previewEdges.map((previewEdge)=>{
             const sourceIsPreviewNode = previewEdge.source === external_constants_cjs_namespaceObject.PREVIEW_NODE_ID;
             const existingNodeId = sourceIsPreviewNode ? previewEdge.target : previewEdge.source;
-            const existingNode = reactFlowInstance.getNode(existingNodeId);
-            const existingNodeType = existingNode?.type;
-            const existingNodeVersion = 'string' == typeof existingNode?.data?.version ? existingNode.data.version : void 0;
-            const existingNodeManifest = existingNodeType ? registry?.getManifest(existingNodeType, existingNodeVersion) : void 0;
+            const existingNodeType = reactFlowInstance.getNode(existingNodeId)?.type;
+            const existingNodeManifest = existingNodeType ? registry?.getManifest(existingNodeType) : void 0;
             const existingHandleId = sourceIsPreviewNode ? previewEdge.targetHandle || 'input' : previewEdge.sourceHandle || 'output';
             const existingHandleManifest = existingNodeManifest?.handleConfiguration.flatMap((hg)=>hg.handles).find((h)=>{
                 if (h.id === existingHandleId) return true;

package/dist/canvas/hooks/usePreviewNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePreviewNode.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/usePreviewNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,IAAI,EAIV,MAAM,0CAA0C,CAAC;AAKlD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAQ9E,MAAM,WAAW,yBAAyB;IAExC,cAAc,EAAE,MAAM,CAAC;IAEvB,gBAAgB,EAAE,MAAM,CAAC;IAEzB,oBAAoB,EAAE,YAAY,GAAG,SAAS,CAAC;IAE/C,sBAAsB,EAAE,cAAc,GAAG,SAAS,CAAC;IAEnD,kBAAkB,EAAE,OAAO,CAAC;IAE5B,aAAa,EAAE,MAAM,CAAC;CACvB;AAsBD,UAAU,oBAAoB;IAE5B,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IAKzB,yBAAyB,EAAE,KAAK,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAC;CACpE;AAcD,eAAO,MAAM,cAAc,QAAO,oBAiEjC,CAAC"}
+{"version":3,"file":"usePreviewNode.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/usePreviewNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,IAAI,EAIV,MAAM,0CAA0C,CAAC;AAKlD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAQ9E,MAAM,WAAW,yBAAyB;IAExC,cAAc,EAAE,MAAM,CAAC;IAEvB,gBAAgB,EAAE,MAAM,CAAC;IAEzB,oBAAoB,EAAE,YAAY,GAAG,SAAS,CAAC;IAE/C,sBAAsB,EAAE,cAAc,GAAG,SAAS,CAAC;IAEnD,kBAAkB,EAAE,OAAO,CAAC;IAE5B,aAAa,EAAE,MAAM,CAAC;CACvB;AAsBD,UAAU,oBAAoB;IAE5B,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IAKzB,yBAAyB,EAAE,KAAK,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAC;CACpE;AAcD,eAAO,MAAM,cAAc,QAAO,oBA8DjC,CAAC"}

package/dist/canvas/hooks/usePreviewNode.js

@@ -25,10 +25,8 @@ const usePreviewNode = ()=>{
         const connections = previewEdges.map((previewEdge)=>{
             const sourceIsPreviewNode = previewEdge.source === PREVIEW_NODE_ID;
             const existingNodeId = sourceIsPreviewNode ? previewEdge.target : previewEdge.source;
-            const existingNode = reactFlowInstance.getNode(existingNodeId);
-            const existingNodeType = existingNode?.type;
-            const existingNodeVersion = 'string' == typeof existingNode?.data?.version ? existingNode.data.version : void 0;
-            const existingNodeManifest = existingNodeType ? registry?.getManifest(existingNodeType, existingNodeVersion) : void 0;
+            const existingNodeType = reactFlowInstance.getNode(existingNodeId)?.type;
+            const existingNodeManifest = existingNodeType ? registry?.getManifest(existingNodeType) : void 0;
             const existingHandleId = sourceIsPreviewNode ? previewEdge.targetHandle || 'input' : previewEdge.sourceHandle || 'output';
             const existingHandleManifest = existingNodeManifest?.handleConfiguration.flatMap((hg)=>hg.handles).find((h)=>{
                 if (h.id === existingHandleId) return true;

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

@@ -25,11 +25,10 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     handleConfigurationSpecificPositionSchema: ()=>handleConfigurationSpecificPositionSchema,
+    handleTypeDisplaySchema: ()=>handleTypeDisplaySchema,
+    handleTypeSchema: ()=>handleTypeSchema,
     handleGroupOverrideSchema: ()=>handleGroupOverrideSchema,
     handlePositionSchema: ()=>handlePositionSchema,
-    handleTypeSchema: ()=>handleTypeSchema,
-    handleTypeDisplaySchema: ()=>handleTypeDisplaySchema,
-    handleBoundarySchema: ()=>handleBoundarySchema,
     handleGroupManifestSchema: ()=>handleGroupManifestSchema,
     handleManifestSchema: ()=>handleManifestSchema
 });
@@ -41,10 +40,6 @@ const handlePositionSchema = external_zod_namespaceObject.z["enum"]([
     'right',
     'bottom'
 ]);
-const handleBoundarySchema = external_zod_namespaceObject.z["enum"]([
-    'outer',
-    'inner'
-]);
 const handleTypeSchema = external_zod_namespaceObject.z["enum"]([
     'source',
     'target'
@@ -80,7 +75,6 @@ const handleManifestSchema = external_zod_namespaceObject.z.object({
 });
 const handleGroupManifestSchema = external_zod_namespaceObject.z.object({
     position: handlePositionSchema,
-    boundary: handleBoundarySchema.optional(),
     customPositionAndOffsets: handleConfigurationSpecificPositionSchema.optional(),
     handles: external_zod_namespaceObject.z.array(handleManifestSchema),
     visible: external_zod_namespaceObject.z.boolean().optional()
@@ -90,7 +84,6 @@ const handleGroupOverrideSchema = external_zod_namespaceObject.z.object({
     handles: external_zod_namespaceObject.z.array(handleManifestSchema),
     visible: external_zod_namespaceObject.z.boolean().optional()
 });
-exports.handleBoundarySchema = __webpack_exports__.handleBoundarySchema;
 exports.handleConfigurationSpecificPositionSchema = __webpack_exports__.handleConfigurationSpecificPositionSchema;
 exports.handleGroupManifestSchema = __webpack_exports__.handleGroupManifestSchema;
 exports.handleGroupOverrideSchema = __webpack_exports__.handleGroupOverrideSchema;
@@ -99,7 +92,6 @@ exports.handlePositionSchema = __webpack_exports__.handlePositionSchema;
 exports.handleTypeDisplaySchema = __webpack_exports__.handleTypeDisplaySchema;
 exports.handleTypeSchema = __webpack_exports__.handleTypeSchema;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "handleBoundarySchema",
     "handleConfigurationSpecificPositionSchema",
     "handleGroupManifestSchema",
     "handleGroupOverrideSchema",

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

@@ -5,10 +5,6 @@ export declare const handlePositionSchema: z.ZodEnum<{
     bottom: "bottom";
     left: "left";
 }>;
-export declare const handleBoundarySchema: z.ZodEnum<{
-    outer: "outer";
-    inner: "inner";
-}>;
 export declare const handleTypeSchema: z.ZodEnum<{
     target: "target";
     source: "source";
@@ -84,10 +80,6 @@ export declare const handleGroupManifestSchema: z.ZodObject<{
         bottom: "bottom";
         left: "left";
     }>;
-    boundary: z.ZodOptional<z.ZodEnum<{
-        outer: "outer";
-        inner: "inner";
-    }>>;
     customPositionAndOffsets: z.ZodOptional<z.ZodObject<{
         height: z.ZodOptional<z.ZodNumber>;
         width: z.ZodOptional<z.ZodNumber>;
@@ -210,7 +202,6 @@ export declare const handleGroupOverrideSchema: z.ZodObject<{
     visible: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type HandlePosition = z.infer<typeof handlePositionSchema>;
-export type HandleBoundary = z.infer<typeof handleBoundarySchema>;
 export type HandleType = z.infer<typeof handleTypeSchema>;
 export type HandleCategory = z.infer<typeof handleTypeDisplaySchema>;
 export type HandleManifest = z.infer<typeof handleManifestSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/handle.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,oBAAoB;;;;;EAA6C,CAAC;AAC/E,eAAO,MAAM,oBAAoB;;;EAA6B,CAAC;AAK/D,eAAO,MAAM,gBAAgB;;;EAA+B,CAAC;AAK7D,eAAO,MAAM,uBAAuB;;;;EAA0C,CAAC;AAE/E,eAAO,MAAM,yCAAyC;;;;;;;iBAkBpD,CAAC;AAKH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8D/B,CAAC;AAKH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBpC,CAAC;AAMH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AAGH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC"}
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/handle.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,oBAAoB;;;;;EAA6C,CAAC;AAK/E,eAAO,MAAM,gBAAgB;;;EAA+B,CAAC;AAK7D,eAAO,MAAM,uBAAuB;;;;EAA0C,CAAC;AAE/E,eAAO,MAAM,yCAAyC;;;;;;;iBAkBpD,CAAC;AAKH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8D/B,CAAC;AAKH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAC;AAMH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AAGH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC"}

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

@@ -6,10 +6,6 @@ const handlePositionSchema = z["enum"]([
     'right',
     'bottom'
 ]);
-const handleBoundarySchema = z["enum"]([
-    'outer',
-    'inner'
-]);
 const handleTypeSchema = z["enum"]([
     'source',
     'target'
@@ -45,7 +41,6 @@ const handleManifestSchema = z.object({
 });
 const handleGroupManifestSchema = z.object({
     position: handlePositionSchema,
-    boundary: handleBoundarySchema.optional(),
     customPositionAndOffsets: handleConfigurationSpecificPositionSchema.optional(),
     handles: z.array(handleManifestSchema),
     visible: z.boolean().optional()
@@ -55,4 +50,4 @@ const handleGroupOverrideSchema = z.object({
     handles: z.array(handleManifestSchema),
     visible: z.boolean().optional()
 });
-export { handleBoundarySchema, handleConfigurationSpecificPositionSchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema };
+export { handleConfigurationSpecificPositionSchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema };

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

@@ -25,7 +25,6 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     categoryManifestSchema: ()=>external_category_manifest_cjs_namespaceObject.categoryManifestSchema,
-    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,
@@ -33,7 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
     nodeRuntimeConstraintsManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeRuntimeConstraintsManifestSchema,
     handleTypeSchema: ()=>external_handle_cjs_namespaceObject.handleTypeSchema,
     handleTypeDisplaySchema: ()=>external_handle_cjs_namespaceObject.handleTypeDisplaySchema,
-    handleBoundarySchema: ()=>external_handle_cjs_namespaceObject.handleBoundarySchema,
+    nodeDisplayManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeDisplayManifestSchema,
     handleGroupManifestSchema: ()=>external_handle_cjs_namespaceObject.handleGroupManifestSchema,
     handleManifestSchema: ()=>external_handle_cjs_namespaceObject.handleManifestSchema
 });
@@ -41,7 +40,6 @@ const external_category_manifest_cjs_namespaceObject = require("./category-manif
 const external_handle_cjs_namespaceObject = require("./handle.cjs");
 const external_node_manifest_cjs_namespaceObject = require("./node-manifest.cjs");
 exports.categoryManifestSchema = __webpack_exports__.categoryManifestSchema;
-exports.handleBoundarySchema = __webpack_exports__.handleBoundarySchema;
 exports.handleGroupManifestSchema = __webpack_exports__.handleGroupManifestSchema;
 exports.handleGroupOverrideSchema = __webpack_exports__.handleGroupOverrideSchema;
 exports.handleManifestSchema = __webpack_exports__.handleManifestSchema;
@@ -54,7 +52,6 @@ exports.nodeRuntimeConstraintsManifestSchema = __webpack_exports__.nodeRuntimeCo
 exports.nodeShapeSchema = __webpack_exports__.nodeShapeSchema;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "categoryManifestSchema",
-    "handleBoundarySchema",
     "handleGroupManifestSchema",
     "handleGroupOverrideSchema",
     "handleManifestSchema",

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

@@ -1,8 +1,8 @@
 export type { CategoryManifest } from './category-manifest';
 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 { HandleCategory, HandleGroupManifest, HandleGroupOverride, HandleManifest, HandlePosition, HandleType, } from './handle';
+export { 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 { nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema, nodeRuntimeConstraintsManifestSchema, } from './node-manifest';
 //# 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,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,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,eAAe,EACf,oCAAoC,GACrC,MAAM,iBAAiB,CAAC"}

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

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

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

@@ -57,10 +57,6 @@ export declare const nodeManifestSchema: z.ZodObject<{
             bottom: "bottom";
             left: "left";
         }>;
-        boundary: z.ZodOptional<z.ZodEnum<{
-            outer: "outer";
-            inner: "inner";
-        }>>;
         customPositionAndOffsets: z.ZodOptional<z.ZodObject<{
             height: z.ZodOptional<z.ZodNumber>;
             width: z.ZodOptional<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"node-manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/node-manifest.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,eAAe;;;;EAA4C,CAAC;AAKzE,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AAKH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBA2BpC,CAAC;AAQH,eAAO,MAAM,oCAAoC;;;;mBAG/C,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgE7B,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}
+{"version":3,"file":"node-manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/node-manifest.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,eAAe;;;;EAA4C,CAAC;AAKzE,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AAKH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBA2BpC,CAAC;AAQH,eAAO,MAAM,oCAAoC;;;;mBAG/C,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgE7B,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}

package/dist/canvas/storybook-utils/manifests/index.d.ts

@@ -69,7 +69,6 @@ export declare const defaultWorkflowManifest: {
                 } | undefined;
                 isDefaultForType?: boolean | undefined;
             }[];
-            boundary?: "outer" | "inner" | undefined;
             customPositionAndOffsets?: {
                 height?: number | undefined;
                 width?: number | undefined;

package/dist/canvas/storybook-utils/manifests/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/storybook-utils/manifests/index.ts"],"names":[],"mappings":"AAGA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAKnC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAInC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/storybook-utils/manifests/index.ts"],"names":[],"mappings":"AAGA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAKnC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAInC,CAAC"}

package/dist/canvas/storybook-utils/manifests/node-definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-definitions.d.ts","sourceRoot":"","sources":["../../../../src/canvas/storybook-utils/manifests/node-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,eAAO,MAAM,gBAAgB,EAAE,YAAY,EA06B1C,CAAC"}
+{"version":3,"file":"node-definitions.d.ts","sourceRoot":"","sources":["../../../../src/canvas/storybook-utils/manifests/node-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,eAAO,MAAM,gBAAgB,EAAE,YAAY,EAw2B1C,CAAC"}