@@ -406,7 +409,9 @@ export const DmnEditor = React.forwardRef((props: DmnEditorProps, ref: React.Ref
-
+
+
+
diff --git a/packages/dmn-editor/src/boxedExpressions/BoxedExpressionScreen.tsx b/packages/dmn-editor/src/boxedExpressions/BoxedExpressionScreen.tsx
index f46d021d462..dbc155484f7 100644
--- a/packages/dmn-editor/src/boxedExpressions/BoxedExpressionScreen.tsx
+++ b/packages/dmn-editor/src/boxedExpressions/BoxedExpressionScreen.tsx
@@ -286,8 +286,6 @@ export function BoxedExpressionScreen({ container }: { container: React.RefObjec
},
});
- console.log(defaultWidthsById);
-
return {
expression: defaultExpression,
widthsById: defaultWidthsById,
@@ -385,10 +383,10 @@ export function BoxedExpressionScreen({ container }: { container: React.RefObjec
pmmlDocuments={pmmlDocuments}
isResetSupportedOnRootExpression={isResetSupportedOnRootExpression}
expressionHolderId={activeDrgElementId!}
- expressionHolderName={drgElement?.variable?.["@_name"] || drgElement?.["@_name"] || ""}
+ expressionHolderName={drgElement?.variable?.["@_name"] ?? drgElement?.["@_name"] ?? ""}
expressionHolderTypeRef={
- drgElement?.variable?.["@_typeRef"] ||
- expression?.boxedExpression?.["@_typeRef"] ||
+ drgElement?.variable?.["@_typeRef"] ??
+ expression?.boxedExpression?.["@_typeRef"] ??
DmnBuiltInDataType.Undefined
}
expression={expression?.boxedExpression}
@@ -405,7 +403,7 @@ export function BoxedExpressionScreen({ container }: { container: React.RefObjec
);
}
-function drgElementToBoxedExpression(
+export function drgElementToBoxedExpression(
expressionHolder:
| (DMN15__tDecision & { __$$element: "decision" })
| (DMN15__tBusinessKnowledgeModel & { __$$element: "businessKnowledgeModel" })
@@ -418,7 +416,7 @@ function drgElementToBoxedExpression(
}
: {
__$$element: "functionDefinition",
- "@_id": generateUuid(),
+ "@_id": expressionHolder.variable?.["@_id"] ?? generateUuid(),
"@_kind": "FEEL",
expression: undefined!, // SPEC DISCREPANCY: Starting without an expression gives users the ability to select the expression type.
formalParameter: [],
@@ -426,7 +424,16 @@ function drgElementToBoxedExpression(
"@_typeRef": expressionHolder.variable?.["@_typeRef"],
};
} else if (expressionHolder.__$$element === "decision") {
- return expressionHolder.expression;
+ return expressionHolder.expression
+ ? {
+ ...expressionHolder.expression,
+ "@_label":
+ expressionHolder?.variable?.["@_name"] ??
+ expressionHolder.expression["@_label"] ??
+ expressionHolder?.["@_name"],
+ "@_typeRef": expressionHolder?.variable?.["@_typeRef"] ?? expressionHolder.expression["@_typeRef"],
+ }
+ : undefined;
} else {
throw new Error(
`Unknown __$$element of expressionHolder that has an expression '${(expressionHolder as any).__$$element}'.`
diff --git a/packages/dmn-editor/src/boxedExpressions/boxedExpressionIndex.ts b/packages/dmn-editor/src/boxedExpressions/boxedExpressionIndex.ts
new file mode 100644
index 00000000000..ec3d46742d5
--- /dev/null
+++ b/packages/dmn-editor/src/boxedExpressions/boxedExpressionIndex.ts
@@ -0,0 +1,544 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import {
+ DMN15__tConditional,
+ DMN15__tContext,
+ DMN15__tDecisionTable,
+ DMN15__tFilter,
+ DMN15__tFor,
+ DMN15__tFunctionDefinition,
+ DMN15__tInvocation,
+ DMN15__tList,
+ DMN15__tLiteralExpression,
+ DMN15__tQuantified,
+ DMN15__tRelation,
+} from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/ts-gen/types";
+import { AllExpressionTypes, AllExpressions, AllExpressionsWithoutTypes } from "../dataTypes/DataTypeSpec";
+
+interface PathType {
+ type: AllExpressionTypes;
+ root: string;
+}
+
+interface ConditionalExpressionPath extends PathType {
+ type: "conditional";
+ row?: "if" | "else" | "then";
+}
+
+interface ContextExpressionPath extends PathType {
+ type: "context";
+ row?: number;
+ column?: "variable" | "expression";
+}
+
+interface DecisionTablePath extends PathType {
+ type: "decisionTable";
+ header?: "input" | "output";
+ row?: number;
+ column?: number;
+}
+
+interface EveryExpressionPath extends PathType {
+ type: "every";
+ row?: "variable" | "in" | "statisfies";
+}
+
+interface FilterExpressionPath extends PathType {
+ type: "filter";
+ row?: "in" | "match";
+}
+
+interface ForExpressionPath extends PathType {
+ type: "for";
+ row?: "variable" | "in" | "return";
+}
+
+interface FunctionDefinitionExpressionPath extends PathType {
+ type: "functionDefinition";
+ parameterIndex?: number;
+}
+
+interface InvocationExpressionPath extends PathType {
+ type: "invocation";
+ row?: number;
+ column?: "parameter" | "expression";
+}
+
+interface ListExpressionPath extends PathType {
+ type: "list";
+ row?: number;
+}
+
+interface LiteralExpressionPath extends PathType {
+ type: "literalExpression";
+}
+
+interface RelationExpressionPath extends PathType {
+ type: "relation";
+ row?: number;
+ column?: number;
+}
+
+interface SomeExpressionPath extends PathType {
+ type: "some";
+ row?: "variable" | "in" | "statisfies";
+}
+
+export type ExpressionPath =
+ | ConditionalExpressionPath
+ | ContextExpressionPath
+ | DecisionTablePath
+ | EveryExpressionPath
+ | FilterExpressionPath
+ | ForExpressionPath
+ | FunctionDefinitionExpressionPath
+ | InvocationExpressionPath
+ | ListExpressionPath
+ | LiteralExpressionPath
+ | RelationExpressionPath
+ | SomeExpressionPath;
+
+/**
+ * A map of "@_id" to cell (expression) and its path in the expression hierarchy
+ */
+export type BoxedExpressionIndex = Map<
+ string,
+ { expressionPath: ExpressionPath[]; cell: AllExpressionsWithoutTypes | AllExpressionsWithoutTypes[] }
+>;
+
+export function generateBoxedExpressionIndex(
+ expression: AllExpressions,
+ parentMap: BoxedExpressionIndex,
+ parentExpressionPath: ExpressionPath[]
+): BoxedExpressionIndex {
+ const map: BoxedExpressionIndex = parentMap ? parentMap : new Map();
+ switch (expression?.__$$element) {
+ case "conditional":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "conditional", root: expression["@_id"] }],
+ cell: expression,
+ });
+ generateBoxedExpressionIndex(expression.if.expression, map, [
+ ...parentExpressionPath,
+ { type: "conditional", row: "if", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.else.expression, map, [
+ ...parentExpressionPath,
+ { type: "conditional", row: "else", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.then.expression, map, [
+ ...parentExpressionPath,
+ { type: "conditional", row: "then", root: expression["@_id"]! },
+ ]);
+ return map;
+ case "context":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "context", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression.contextEntry?.forEach((ce, row) => {
+ const id = ce.variable?.["@_id"] ?? ce?.["@_id"];
+ id &&
+ ce.variable &&
+ map.set(id, {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "context", row, column: "variable", root: expression["@_id"]! },
+ ],
+ cell: ce.variable,
+ });
+ generateBoxedExpressionIndex(ce.expression, map, [
+ ...parentExpressionPath,
+ { type: "context", row, column: "expression", root: expression["@_id"]! },
+ ]);
+ });
+ return map;
+ case "decisionTable":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "decisionTable", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression.output.forEach(
+ (o, column) =>
+ o["@_id"] &&
+ map.set(o["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "decisionTable", header: "output", row: -1, column, root: expression["@_id"]! },
+ ],
+ cell: o,
+ })
+ );
+ expression.input?.forEach((i, column) => {
+ i["@_id"] &&
+ map.set(i["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "decisionTable", header: "input", row: -1, column, root: expression["@_id"]! },
+ ],
+ cell: i,
+ });
+ });
+ expression.rule?.forEach((r, row) => {
+ r.outputEntry?.forEach(
+ (ro, column) =>
+ ro["@_id"] &&
+ map.set(ro["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "decisionTable", header: "output", row, column, root: expression["@_id"]! },
+ ],
+ cell: ro,
+ })
+ );
+ r.inputEntry?.forEach(
+ (ri, column) =>
+ ri["@_id"] &&
+ map.set(ri["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "decisionTable", header: "input", row, column, root: expression["@_id"]! },
+ ],
+ cell: ri,
+ })
+ );
+ });
+ return map;
+ case "every":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "every", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression["@_id"] &&
+ map.set(`${expression["@_id"]}-iteratorVariable`, {
+ expressionPath: [...parentExpressionPath, { type: "every", row: "variable", root: expression["@_id"] }],
+ cell: expression,
+ });
+ generateBoxedExpressionIndex(expression.in.expression, map, [
+ ...parentExpressionPath,
+ { type: "every", row: "in", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.satisfies.expression, map, [
+ ...parentExpressionPath,
+ { type: "every", row: "statisfies", root: expression["@_id"]! },
+ ]);
+ return map;
+ case "filter":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "filter", root: expression["@_id"] }],
+ cell: expression,
+ });
+ generateBoxedExpressionIndex(expression.in.expression, map, [
+ ...parentExpressionPath,
+ { type: "filter", row: "in", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.match.expression, map, [
+ ...parentExpressionPath,
+ { type: "filter", row: "match", root: expression["@_id"]! },
+ ]);
+ return map;
+ case "for":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "for", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression["@_id"] &&
+ map.set(`${expression["@_id"]}-iteratorVariable`, {
+ expressionPath: [...parentExpressionPath, { type: "for", row: "variable", root: expression["@_id"] }],
+ cell: expression,
+ });
+ generateBoxedExpressionIndex(expression.in.expression, map, [
+ ...parentExpressionPath,
+ { type: "for", row: "in", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.return.expression, map, [
+ ...parentExpressionPath,
+ { type: "for", row: "return", root: expression["@_id"]! },
+ ]);
+ return map;
+ case "functionDefinition":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "functionDefinition", root: expression["@_id"] }],
+ cell: expression,
+ });
+
+ if (expression.expression?.["@_id"]) {
+ generateBoxedExpressionIndex(expression.expression, map, [
+ ...parentExpressionPath,
+ { type: "functionDefinition", parameterIndex: -1, root: expression["@_id"]! },
+ ]);
+ }
+
+ map.set(`${expression["@_id"]}-parameters`, {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "functionDefinition", parameterIndex: 0, root: expression["@_id"]! },
+ ],
+ cell: expression.formalParameter ?? [],
+ });
+ return map;
+ case "invocation":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "invocation", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression.binding?.forEach((b, row) => {
+ b.parameter["@_id"] &&
+ map.set(b.parameter["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "invocation", row, column: "parameter", root: expression["@_id"]! },
+ ],
+ cell: b.parameter,
+ });
+ b.expression &&
+ generateBoxedExpressionIndex(b.expression, map, [
+ ...parentExpressionPath,
+ { type: "invocation", row, column: "expression", root: expression["@_id"]! },
+ ]);
+ });
+ // function call
+ expression.expression &&
+ expression.expression["@_id"] &&
+ map.set(expression.expression["@_id"], {
+ expressionPath: [
+ ...parentExpressionPath,
+ { type: "invocation", row: -1, column: "expression", root: expression["@_id"]! },
+ ],
+ cell: expression.expression,
+ });
+ return map;
+ case "list":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "list", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression.expression?.forEach((e, row) =>
+ generateBoxedExpressionIndex(e, map, [
+ ...parentExpressionPath,
+ { type: "list", row, root: expression["@_id"]! },
+ ])
+ );
+ return map;
+ case "literalExpression":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "literalExpression", root: expression["@_id"] }],
+ cell: expression,
+ });
+ return map;
+ case "relation":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "relation", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression.column?.forEach(
+ (c, column) =>
+ c["@_id"] &&
+ map.set(c["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "relation", row: -1, column, root: expression["@_id"]! }],
+ cell: c,
+ })
+ );
+ expression.row?.forEach((r, row) =>
+ r.expression?.forEach((re, column) => {
+ re["@_id"] &&
+ map.set(re["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "relation", row, column, root: expression["@_id"]! }],
+ cell: re,
+ });
+ })
+ );
+ return map;
+ case "some":
+ expression["@_id"] &&
+ map.set(expression["@_id"], {
+ expressionPath: [...parentExpressionPath, { type: "some", root: expression["@_id"] }],
+ cell: expression,
+ });
+ expression["@_id"] &&
+ map.set(`${expression["@_id"]}-iteratorVariable`, {
+ expressionPath: [...parentExpressionPath, { type: "some", row: "variable", root: expression["@_id"] }],
+ cell: expression,
+ });
+ generateBoxedExpressionIndex(expression.in.expression, map, [
+ ...parentExpressionPath,
+ { type: "some", row: "in", root: expression["@_id"]! },
+ ]);
+ generateBoxedExpressionIndex(expression.satisfies.expression, map, [
+ ...parentExpressionPath,
+ { type: "some", row: "statisfies", root: expression["@_id"]! },
+ ]);
+ return map;
+ }
+}
+
+export function getDmnObjectByPath(
+ paths: ExpressionPath[],
+ expressionRoot?: AllExpressionsWithoutTypes
+): AllExpressionsWithoutTypes | undefined {
+ if (!expressionRoot) {
+ return;
+ }
+ return paths.reduce((expressionToEdit: AllExpressionsWithoutTypes, path) => {
+ if (path.type === "conditional") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tConditional;
+ }
+ if (path.row === "if") {
+ return (expressionToEdit as DMN15__tConditional).if.expression;
+ }
+ if (path.row === "else") {
+ return (expressionToEdit as DMN15__tConditional).else.expression;
+ }
+ return (expressionToEdit as DMN15__tConditional).then.expression;
+ }
+ if (path.type === "context") {
+ // root
+ if (path.row === undefined || path.column === undefined) {
+ return expressionToEdit as DMN15__tContext;
+ }
+ if (path.column === "expression") {
+ return (expressionToEdit as DMN15__tContext).contextEntry?.[path.row].expression;
+ }
+ return (expressionToEdit as DMN15__tContext).contextEntry?.[path.row].variable;
+ }
+ if (path.type === "decisionTable") {
+ // root
+ if (path.row === undefined || path.column === undefined) {
+ return expressionToEdit as DMN15__tDecisionTable;
+ }
+ if (path.header === "input") {
+ if (path.row < 0) {
+ return (expressionToEdit as DMN15__tDecisionTable).input?.[path.column];
+ }
+ return (expressionToEdit as DMN15__tDecisionTable).rule?.[path.row].inputEntry?.[path.column];
+ }
+ if (path.row < 0) {
+ return (expressionToEdit as DMN15__tDecisionTable).output?.[path.column];
+ }
+ return (expressionToEdit as DMN15__tDecisionTable).rule?.[path.row].outputEntry?.[path.column];
+ }
+ if (path.type === "every") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tQuantified;
+ }
+ if (path.row === "variable") {
+ return expressionToEdit as DMN15__tQuantified;
+ }
+ if (path.row === "in") {
+ return (expressionToEdit as DMN15__tQuantified).in.expression;
+ }
+ return (expressionToEdit as DMN15__tQuantified).satisfies.expression;
+ }
+ if (path.type === "filter") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tFilter;
+ }
+ if (path.row === "in") {
+ return (expressionToEdit as DMN15__tFilter).in.expression;
+ }
+ return (expressionToEdit as DMN15__tFilter).match.expression;
+ }
+ if (path.type === "for") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tFor;
+ }
+ if (path.row === "variable") {
+ return expressionToEdit as DMN15__tFor;
+ }
+ if (path.row === "in") {
+ return (expressionToEdit as DMN15__tFor).in.expression;
+ }
+ return (expressionToEdit as DMN15__tFor).return.expression;
+ }
+ if (path.type === "functionDefinition") {
+ // root
+ if (!path.parameterIndex) {
+ return expressionToEdit as DMN15__tFunctionDefinition;
+ }
+ if (path.parameterIndex < 0) {
+ return (expressionToEdit as DMN15__tFunctionDefinition).expression;
+ }
+ return expressionToEdit as DMN15__tFunctionDefinition;
+ }
+ if (path.type === "invocation") {
+ // root
+ if (path.row === undefined || path.column === undefined) {
+ return expressionToEdit as DMN15__tInvocation;
+ }
+ if (path.column === "parameter") {
+ return (expressionToEdit as DMN15__tInvocation).binding?.[path.row].parameter;
+ }
+ if (path.column === "expression" && path.row >= 0) {
+ return (expressionToEdit as DMN15__tInvocation).binding?.[path.row].expression;
+ }
+ // function call
+ return (expressionToEdit as DMN15__tInvocation).expression;
+ }
+ if (path.type === "list") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tList;
+ }
+ return (expressionToEdit as DMN15__tList).expression?.[path.row];
+ }
+ if (path.type === "literalExpression") {
+ return expressionToEdit as DMN15__tLiteralExpression;
+ }
+ if (path.type === "relation") {
+ // root
+ if (path.row === undefined || path.column === undefined) {
+ return expressionToEdit as DMN15__tRelation;
+ }
+ if (path.row < 0) {
+ return (expressionToEdit as DMN15__tRelation).column?.[path.column];
+ }
+ return (expressionToEdit as DMN15__tRelation).row?.[path.row].expression?.[path.column];
+ }
+ if (path.type === "some") {
+ // root
+ if (path.row === undefined) {
+ return expressionToEdit as DMN15__tQuantified;
+ }
+ if (path.row === "variable") {
+ return expressionToEdit as DMN15__tQuantified;
+ }
+ if (path.row === "in") {
+ return (expressionToEdit as DMN15__tQuantified).in.expression;
+ }
+ return (expressionToEdit as DMN15__tQuantified).satisfies.expression;
+ }
+ }, expressionRoot);
+}
diff --git a/packages/dmn-editor/src/commands/CommandsContextProvider.tsx b/packages/dmn-editor/src/commands/CommandsContextProvider.tsx
new file mode 100644
index 00000000000..ab664a26388
--- /dev/null
+++ b/packages/dmn-editor/src/commands/CommandsContextProvider.tsx
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import * as React from "react";
+import { useContext, useRef } from "react";
+
+export interface Commands {
+ hideFromDrd: () => void;
+ toggleHierarchyHighlight: () => void;
+ togglePropertiesPanel: () => void;
+ createGroup: () => void;
+ selectAll: () => void;
+ panDown: () => void;
+ panUp: () => void;
+ paste: () => void;
+ copy: () => void;
+ cut: () => void;
+ cancelAction: () => void;
+ focusOnSelection: () => void;
+ resetPosition: () => void;
+}
+
+const CommandsContext = React.createContext<{
+ commandsRef: React.MutableRefObject
;
+}>({} as any);
+
+export function useCommands() {
+ return useContext(CommandsContext);
+}
+
+export function CommandsContextProvider(props: React.PropsWithChildren<{}>) {
+ const commandsRef = useRef({
+ hideFromDrd: () => {
+ throw new Error("DMN EDITOR: hideFromDrd command not implemented.");
+ },
+ toggleHierarchyHighlight: () => {
+ throw new Error("DMN EDITOR: toggleHierarchyHighlight command not implemented.");
+ },
+ togglePropertiesPanel: () => {
+ throw new Error("DMN EDITOR: togglePropertiesPanel command not implemented.");
+ },
+ createGroup: () => {
+ throw new Error("DMN EDITOR: createGroup command not implemented.");
+ },
+ selectAll: () => {
+ throw new Error("DMN EDITOR: selectAll command not implemented.");
+ },
+ panDown: () => {
+ throw new Error("DMN EDITOR: panDown command not implemented.");
+ },
+ panUp: () => {
+ throw new Error("DMN EDITOR: panUp command not implemented.");
+ },
+ paste: () => {
+ throw new Error("DMN EDITOR: paste command not implemented.");
+ },
+ copy: () => {
+ throw new Error("DMN EDITOR: copy command not implemented.");
+ },
+ cut: () => {
+ throw new Error("DMN EDITOR: cut command not implemented.");
+ },
+ cancelAction: () => {
+ throw new Error("DMN EDITOR: cancelAction command not implemented.");
+ },
+ focusOnSelection: () => {
+ throw new Error("DMN EDITOR: focusOnSelection command not implemented.");
+ },
+ resetPosition: () => {
+ throw new Error("DMN EDITOR: resetPosition command not implemented.");
+ },
+ });
+
+ return {props.children};
+}
diff --git a/packages/dmn-editor/src/dataTypes/Constraints.tsx b/packages/dmn-editor/src/dataTypes/Constraints.tsx
index 8f3579b6d4f..9a2b93230af 100644
--- a/packages/dmn-editor/src/dataTypes/Constraints.tsx
+++ b/packages/dmn-editor/src/dataTypes/Constraints.tsx
@@ -18,7 +18,7 @@
*/
import * as React from "react";
-import { useMemo, useCallback } from "react";
+import { useMemo, useCallback, useState, useEffect } from "react";
import { ConstraintsExpression } from "./ConstraintsExpression";
import {
DMN15__tItemDefinition,
@@ -28,9 +28,9 @@ import { DmnBuiltInDataType, generateUuid } from "@kie-tools/boxed-expression-co
import { ConstraintsEnum, isEnum } from "./ConstraintsEnum";
import { ConstraintsRange, isRange } from "./ConstraintsRange";
import { KIE__tConstraintType } from "@kie-tools/dmn-marshaller/dist/schemas/kie-1_0/ts-gen/types";
-import { EditItemDefinition } from "./DataTypes";
+import { DataTypeIndex, EditItemDefinition } from "./DataTypes";
import { ToggleGroup, ToggleGroupItem } from "@patternfly/react-core/dist/js/components/ToggleGroup";
-import { constrainableBuiltInFeelTypes } from "./DataTypeSpec";
+import { constrainableBuiltInFeelTypes, isCollection, isStruct } from "./DataTypeSpec";
import moment from "moment";
import { TextInput } from "@patternfly/react-core/dist/js/components/TextInput";
import { ConstraintDate } from "./ConstraintComponents/ConstraintDate";
@@ -46,6 +46,10 @@ import {
} from "./ConstraintComponents/ConstraintYearsMonthsDuration";
import { invalidInlineFeelNameStyle } from "../feel/InlineFeelNameInput";
import { ConstraintProps } from "./ConstraintComponents/Constraint";
+import { useDmnEditorStore } from "../store/StoreContext";
+import { useExternalModels } from "../includedModels/DmnEditorDependenciesContext";
+import { UniqueNameIndex } from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/Dmn15Spec";
+import { builtInFeelTypeNames } from "./BuiltInFeelTypes";
export type TypeHelper = {
check: (value: string) => boolean;
@@ -56,6 +60,7 @@ export type TypeHelper = {
};
export interface ConstraintComponentProps {
+ id: string;
isReadonly: boolean;
value?: string;
expressionValue?: string;
@@ -63,6 +68,7 @@ export interface ConstraintComponentProps {
typeHelper: TypeHelper;
onSave: (value?: string) => void;
isDisabled: boolean;
+ renderOnPropertiesPanel?: boolean;
}
enum ConstraintsType {
@@ -72,31 +78,71 @@ enum ConstraintsType {
NONE = "None",
}
-export const constraintTypeHelper = (typeRef: DmnBuiltInDataType): TypeHelper => {
- return {
+// Recurse the `itemDefinition` until find `typeRef` attribute
+// that is part of the built in FEEL types.
+// If the found `itemDefinition` is a collection, it will have a early stop.
+export function recursivelyGetRootItemDefinition(
+ itemDefinition: DMN15__tItemDefinition,
+ allDataTypesById: DataTypeIndex,
+ allTopLevelItemDefinitionUniqueNames: UniqueNameIndex
+): DMN15__tItemDefinition {
+ const typeRef: DmnBuiltInDataType =
+ (itemDefinition.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined;
+
+ if (builtInFeelTypeNames.has(typeRef) === false) {
+ const parentDataType = allDataTypesById.get(allTopLevelItemDefinitionUniqueNames.get(typeRef) ?? "");
+ if (parentDataType !== undefined && isCollection(parentDataType.itemDefinition)) {
+ // Parent `itemDefinition` is a collection. Early stop.
+ return parentDataType.itemDefinition;
+ } else if (parentDataType !== undefined) {
+ return recursivelyGetRootItemDefinition(
+ parentDataType.itemDefinition,
+ allDataTypesById,
+ allTopLevelItemDefinitionUniqueNames
+ );
+ }
+ // Something wrong. Caller `itemDefinition` isn't a built-in FEEL type and doesn't have parent.
+ return itemDefinition;
+ }
+ // Caller `itemDefinition` is a built-in FEEL type
+ return itemDefinition;
+}
+
+export const constraintTypeHelper = (
+ itemDefinition: DMN15__tItemDefinition,
+ allDataTypesById?: DataTypeIndex,
+ allTopLevelItemDefinitionUniqueNames?: UniqueNameIndex
+): TypeHelper => {
+ const typeRef =
+ (allDataTypesById !== undefined && allTopLevelItemDefinitionUniqueNames !== undefined
+ ? recursivelyGetRootItemDefinition(itemDefinition, allDataTypesById, allTopLevelItemDefinitionUniqueNames).typeRef
+ ?.__$$text
+ : itemDefinition.typeRef?.__$$text) ?? DmnBuiltInDataType.Undefined;
+
+ const typeHelper = {
// check if the value has the correct type
- check: (value: string) => {
- const recoveredValue = constraintTypeHelper(typeRef).recover(value);
- switch (typeRef) {
+ check: (value: string, type?: DmnBuiltInDataType) => {
+ const recoveredValue = typeHelper.recover(value);
+ switch (type ?? typeRef) {
case DmnBuiltInDataType.Any:
return true;
case DmnBuiltInDataType.String:
if (recoveredValue === "") {
return true;
}
- if (constraintTypeHelper(DmnBuiltInDataType.Date).check(value)) {
+ if (typeHelper.check(value, DmnBuiltInDataType.Date)) {
return false;
}
- if (constraintTypeHelper(DmnBuiltInDataType.DateTime).check(value)) {
+ if (typeHelper.check(value, DmnBuiltInDataType.DateTime)) {
return false;
}
- if (constraintTypeHelper(DmnBuiltInDataType.DateTimeDuration).check(value)) {
+ if (typeHelper.check(value, DmnBuiltInDataType.DateTimeDuration)) {
return false;
}
- if (constraintTypeHelper(DmnBuiltInDataType.Time).check(value)) {
+ if (typeHelper.check(value, DmnBuiltInDataType.Time)) {
return false;
}
- if (constraintTypeHelper(DmnBuiltInDataType.YearsMonthsDuration).check(value)) {
+ if (typeHelper.check(value, DmnBuiltInDataType.YearsMonthsDuration)) {
return false;
}
return typeof recoveredValue === "string";
@@ -124,7 +170,7 @@ export const constraintTypeHelper = (typeRef: DmnBuiltInDataType): TypeHelper =>
// parse the value to the type
// useful for comparisons
parse: (value: string) => {
- const recoveredValue = constraintTypeHelper(typeRef).recover(value);
+ const recoveredValue = typeHelper.recover(value);
switch (typeRef) {
case DmnBuiltInDataType.Number:
return parseFloat(recoveredValue ?? "");
@@ -162,7 +208,7 @@ export const constraintTypeHelper = (typeRef: DmnBuiltInDataType): TypeHelper =>
}
},
// recover the value before use it
- recover: (value?: string) => {
+ recover: (value: string | undefined) => {
if (value === undefined) {
return undefined;
}
@@ -247,41 +293,39 @@ export const constraintTypeHelper = (typeRef: DmnBuiltInDataType): TypeHelper =>
}
},
};
+ return typeHelper;
};
export function useConstraint({
constraint,
itemDefinition,
- isCollectionConstraintEnable,
+ isCollectionConstraintEnabled,
+ constraintTypeHelper,
+ enabledConstraints,
}: {
constraint: DMN15__tUnaryTests | undefined;
itemDefinition: DMN15__tItemDefinition;
- isCollectionConstraintEnable: boolean;
+ isCollectionConstraintEnabled: boolean;
+ constraintTypeHelper: TypeHelper;
+ enabledConstraints: KIE__tConstraintType[] | undefined;
}) {
- const constraintValue = useMemo(() => constraint?.text.__$$text, [constraint?.text.__$$text]);
- const kieConstraintType = useMemo(() => constraint?.["@_kie:constraintType"], [constraint]);
- const isCollection = useMemo(() => itemDefinition["@_isCollection"] ?? false, [itemDefinition]);
- const itemDefinitionId = useMemo(() => itemDefinition["@_id"], [itemDefinition]);
-
- const typeRef: DmnBuiltInDataType = useMemo(
- () => (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined,
- [itemDefinition?.typeRef?.__$$text]
- );
+ const constraintValue = constraint?.text.__$$text;
+ const kieConstraintType = constraint?.["@_kie:constraintType"];
const isConstraintEnum = useMemo(
() =>
- isCollection === true && isCollectionConstraintEnable === true // collection doesn't support enumeration constraint
+ isCollection(itemDefinition) === true && isCollectionConstraintEnabled === true // collection doesn't support enumeration constraint
? undefined
- : isEnum(constraintValue, constraintTypeHelper(typeRef).check),
- [constraintValue, isCollectionConstraintEnable, isCollection, typeRef]
+ : isEnum(constraintValue, constraintTypeHelper.check),
+ [constraintTypeHelper.check, constraintValue, isCollectionConstraintEnabled, itemDefinition]
);
const isConstraintRange = useMemo(
() =>
- isCollection === true && isCollectionConstraintEnable === true // collection doesn't support range constraint
+ isCollection(itemDefinition) === true && isCollectionConstraintEnabled === true // collection doesn't support range constraint
? undefined
- : isRange(constraintValue, constraintTypeHelper(typeRef).check),
- [constraintValue, isCollectionConstraintEnable, isCollection, typeRef]
+ : isRange(constraintValue, constraintTypeHelper.check),
+ [constraintTypeHelper.check, constraintValue, isCollectionConstraintEnabled, itemDefinition]
);
const enumToKieConstraintType: (selection: ConstraintsType) => KIE__tConstraintType | undefined = useCallback(
@@ -302,21 +346,20 @@ export function useConstraint({
);
const isConstraintEnabled = useMemo(() => {
- const enabledConstraints = constrainableBuiltInFeelTypes.get(typeRef);
return {
enumeration:
- !(isCollection === true && isCollectionConstraintEnable === true) &&
+ !(isCollection(itemDefinition) === true && isCollectionConstraintEnabled === true) &&
(enabledConstraints ?? []).includes(enumToKieConstraintType(ConstraintsType.ENUMERATION)!),
range:
- !(isCollection === true && isCollectionConstraintEnable === true) &&
+ !(isCollection(itemDefinition) === true && isCollectionConstraintEnabled === true) &&
(enabledConstraints ?? []).includes(enumToKieConstraintType(ConstraintsType.RANGE)!),
expression:
- (isCollection === true && isCollectionConstraintEnable === true) ||
+ (isCollection(itemDefinition) === true && isCollectionConstraintEnabled === true) ||
(enabledConstraints ?? []).includes(enumToKieConstraintType(ConstraintsType.EXPRESSION)!),
};
- }, [typeRef, isCollection, isCollectionConstraintEnable, enumToKieConstraintType]);
+ }, [enabledConstraints, enumToKieConstraintType, isCollectionConstraintEnabled, itemDefinition]);
- const selectedConstraint = useMemo(() => {
+ const selectedKieConstraintType = useMemo(() => {
if (isConstraintEnabled.enumeration && kieConstraintType === "enumeration") {
return ConstraintsType.ENUMERATION;
}
@@ -346,136 +389,153 @@ export function useConstraint({
kieConstraintType,
]);
- return useMemo(() => {
- return {
- constraintValue,
- typeRef,
- isConstraintEnum,
- isConstraintRange,
- isConstraintEnabled,
- itemDefinitionId,
- selectedConstraint,
- enumToKieConstraintType,
- };
- }, [
+ return {
constraintValue,
- isConstraintEnabled,
isConstraintEnum,
isConstraintRange,
- itemDefinitionId,
- selectedConstraint,
- typeRef,
+ isConstraintEnabled,
+ selectedKieConstraintType,
enumToKieConstraintType,
- ]);
+ };
}
export function ConstraintsFromAllowedValuesAttribute({
isReadonly,
itemDefinition,
editItemDefinition,
+ renderOnPropertiesPanel,
}: {
isReadonly: boolean;
itemDefinition: DMN15__tItemDefinition;
editItemDefinition: EditItemDefinition;
+ renderOnPropertiesPanel?: boolean;
isEnumDisabled?: boolean;
isRangeDisabled?: boolean;
}) {
+ const { externalModelsByNamespace } = useExternalModels();
+ const allDataTypesById = useDmnEditorStore(
+ (s) => s.computed(s).getDataTypes(externalModelsByNamespace).allDataTypesById
+ );
+ const allTopLevelItemDefinitionUniqueNames = useDmnEditorStore(
+ (s) => s.computed(s).getDataTypes(externalModelsByNamespace).allTopLevelItemDefinitionUniqueNames
+ );
+
const allowedValues = useMemo(() => itemDefinition?.allowedValues, [itemDefinition?.allowedValues]);
+ const itemDefinitionId = itemDefinition["@_id"]!;
+ const typeRef = (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined;
+ const typeRefConstraintTypeHelper = useMemo(
+ () => constraintTypeHelper(itemDefinition, allDataTypesById, allTopLevelItemDefinitionUniqueNames),
+ [allDataTypesById, allTopLevelItemDefinitionUniqueNames, itemDefinition]
+ );
+
+ const rootItemDefinition = useMemo(
+ () => recursivelyGetRootItemDefinition(itemDefinition, allDataTypesById, allTopLevelItemDefinitionUniqueNames),
+ [allDataTypesById, allTopLevelItemDefinitionUniqueNames, itemDefinition]
+ );
+
+ const enabledConstraints = useMemo(
+ () =>
+ isStruct(rootItemDefinition)
+ ? (["expression"] as KIE__tConstraintType[])
+ : constrainableBuiltInFeelTypes.get(
+ (rootItemDefinition.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
+ ),
+ [rootItemDefinition]
+ );
+
+ // Collection constraint on the `allowedValues` must be enabled on cases where `rootItemDefinition` is a collection
+ const isCollectionConstraintEnable = useMemo(() => {
+ if (itemDefinitionId !== rootItemDefinition["@_id"]) {
+ return rootItemDefinition["@_isCollection"] ?? false;
+ }
+ return false;
+ }, [itemDefinitionId, rootItemDefinition]);
const {
constraintValue,
- typeRef,
isConstraintEnum,
isConstraintRange,
isConstraintEnabled,
- itemDefinitionId,
- selectedConstraint,
+ selectedKieConstraintType,
enumToKieConstraintType,
} = useConstraint({
constraint: allowedValues,
itemDefinition,
- isCollectionConstraintEnable: false, // allowedValues doesn't support constraint to the collection itself
+ isCollectionConstraintEnabled: isCollectionConstraintEnable,
+ constraintTypeHelper: typeRefConstraintTypeHelper,
+ enabledConstraints,
});
const onConstraintChange = useCallback(
- (value?: string) => {
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
- itemDefinition.allowedValues ??= { text: { __$$text: "" } };
- itemDefinition.allowedValues.text.__$$text = value ?? "";
- itemDefinition.allowedValues["@_id"] = itemDefinition.allowedValues?.["@_id"] ?? generateUuid();
- return;
+ (value: string | undefined, selectedConstraint: ConstraintsType) => {
+ editItemDefinition(itemDefinitionId, (itemDefinition) => {
+ if (value === "" || value === undefined) {
+ itemDefinition.allowedValues = undefined;
+ } else {
+ itemDefinition.allowedValues ??= { text: { __$$text: "" } };
+ itemDefinition.allowedValues.text.__$$text = value;
+ itemDefinition.allowedValues["@_id"] = itemDefinition.allowedValues?.["@_id"] ?? generateUuid();
+ itemDefinition.allowedValues["@_kie:constraintType"] = enumToKieConstraintType(selectedConstraint);
+ }
});
},
- [editItemDefinition, itemDefinitionId]
+ [editItemDefinition, enumToKieConstraintType, itemDefinitionId]
);
const onToggleGroupChange = useCallback(
- (newSelection: boolean, event: React.KeyboardEvent | MouseEvent | React.MouseEvent) => {
+ (newSelection: boolean, selectedConstraint: ConstraintsType) => {
if (!newSelection) {
return;
}
- const selection = event.currentTarget.id as ConstraintsType;
- if (selection === ConstraintsType.NONE) {
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
+
+ editItemDefinition(itemDefinitionId, (itemDefinition) => {
+ if (selectedConstraint === ConstraintsType.NONE) {
itemDefinition.allowedValues = undefined;
- });
- return;
- }
+ return;
+ }
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
- itemDefinition.allowedValues ??= { text: { __$$text: "" } };
- const previousKieContraintType = itemDefinition.allowedValues["@_kie:constraintType"];
- itemDefinition.allowedValues["@_kie:constraintType"] = enumToKieConstraintType(selection);
+ if (itemDefinition.allowedValues) {
+ itemDefinition.allowedValues["@_kie:constraintType"] = enumToKieConstraintType(selectedConstraint);
+ }
- if (selection === ConstraintsType.EXPRESSION) {
+ if (selectedConstraint === ConstraintsType.EXPRESSION) {
return;
}
if (
- previousKieContraintType === "expression" &&
- selection === ConstraintsType.ENUMERATION &&
- isEnum(
- itemDefinition.allowedValues.text.__$$text,
- constraintTypeHelper(
- (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
- ).check
- )
+ selectedConstraint === ConstraintsType.ENUMERATION &&
+ isEnum(itemDefinition.allowedValues?.text.__$$text, typeRefConstraintTypeHelper.check)
) {
return;
}
if (
- previousKieContraintType === "expression" &&
- selection === ConstraintsType.RANGE &&
- isRange(
- itemDefinition.allowedValues.text.__$$text,
- constraintTypeHelper(
- (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
- ).check
- )
+ selectedConstraint === ConstraintsType.RANGE &&
+ isRange(itemDefinition.allowedValues?.text.__$$text, typeRefConstraintTypeHelper.check)
) {
return;
}
- itemDefinition.allowedValues.text.__$$text = "";
- return;
+ itemDefinition.allowedValues = undefined;
});
},
- [editItemDefinition, enumToKieConstraintType, itemDefinitionId]
+ [editItemDefinition, itemDefinitionId, enumToKieConstraintType, typeRefConstraintTypeHelper.check]
);
return (
);
}
@@ -484,13 +544,23 @@ export function ConstraintsFromTypeConstraintAttribute({
isReadonly,
itemDefinition,
editItemDefinition,
+ renderOnPropertiesPanel,
defaultsToAllowedValues,
}: {
isReadonly: boolean;
itemDefinition: DMN15__tItemDefinition;
editItemDefinition: EditItemDefinition;
+ renderOnPropertiesPanel?: boolean;
defaultsToAllowedValues: boolean;
}) {
+ const { externalModelsByNamespace } = useExternalModels();
+ const allDataTypesById = useDmnEditorStore(
+ (s) => s.computed(s).getDataTypes(externalModelsByNamespace).allDataTypesById
+ );
+ const allTopLevelItemDefinitionUniqueNames = useDmnEditorStore(
+ (s) => s.computed(s).getDataTypes(externalModelsByNamespace).allTopLevelItemDefinitionUniqueNames
+ );
+ const itemDefinitionId = itemDefinition["@_id"]!;
const typeConstraint = useMemo(
() =>
defaultsToAllowedValues
@@ -499,117 +569,136 @@ export function ConstraintsFromTypeConstraintAttribute({
[defaultsToAllowedValues, itemDefinition?.allowedValues, itemDefinition?.typeConstraint]
);
+ const typeRef = (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined;
+ const typeRefConstraintTypeHelper = useMemo(
+ () => constraintTypeHelper(itemDefinition, allDataTypesById, allTopLevelItemDefinitionUniqueNames),
+ [allDataTypesById, allTopLevelItemDefinitionUniqueNames, itemDefinition]
+ );
+
+ const rootItemDefinition = useMemo(
+ () => recursivelyGetRootItemDefinition(itemDefinition, allDataTypesById, allTopLevelItemDefinitionUniqueNames),
+ [allDataTypesById, allTopLevelItemDefinitionUniqueNames, itemDefinition]
+ );
+
+ const enabledConstraints = useMemo(() => {
+ if (isStruct(rootItemDefinition)) {
+ return ["expression"] as KIE__tConstraintType[];
+ }
+ if (isCollection(rootItemDefinition)) {
+ return ["expression"] as KIE__tConstraintType[];
+ }
+ return constrainableBuiltInFeelTypes.get(
+ (rootItemDefinition.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
+ );
+ }, [rootItemDefinition]);
+
const {
constraintValue,
- typeRef,
isConstraintEnum,
isConstraintRange,
isConstraintEnabled,
- itemDefinitionId,
- selectedConstraint,
+ selectedKieConstraintType,
enumToKieConstraintType,
} = useConstraint({
constraint: typeConstraint,
- itemDefinition,
- isCollectionConstraintEnable: true, // typeConstraint enables to add a constraint to the collection itself
+ itemDefinition: itemDefinition,
+ isCollectionConstraintEnabled: true, // typeConstraint enables to add a constraint to the collection itself
+ constraintTypeHelper: typeRefConstraintTypeHelper,
+ enabledConstraints,
});
const onConstraintChange = useCallback(
- (value?: string) => {
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
- itemDefinition.typeConstraint ??= { text: { __$$text: "" } };
- itemDefinition.typeConstraint.text.__$$text = value ?? "";
- itemDefinition.typeConstraint["@_id"] = itemDefinition.typeConstraint?.["@_id"] ?? generateUuid();
+ (value: string | undefined, selectedConstraint: ConstraintsType) => {
+ editItemDefinition(itemDefinitionId, (itemDefinition) => {
+ if (value === "" || value === undefined) {
+ itemDefinition.typeConstraint = undefined;
+ } else {
+ itemDefinition.typeConstraint ??= { text: { __$$text: "" } };
+ itemDefinition.typeConstraint.text.__$$text = value;
+ itemDefinition.typeConstraint["@_id"] = itemDefinition.typeConstraint?.["@_id"] ?? generateUuid();
+ itemDefinition.typeConstraint["@_kie:constraintType"] = enumToKieConstraintType(selectedConstraint);
+ }
});
},
- [editItemDefinition, itemDefinitionId]
+ [editItemDefinition, enumToKieConstraintType, itemDefinitionId]
);
const onToggleGroupChange = useCallback(
- (newSelection: boolean, event: React.KeyboardEvent | MouseEvent | React.MouseEvent) => {
+ (newSelection: boolean, selectedConstraint: ConstraintsType) => {
if (!newSelection) {
return;
}
- const selection = event.currentTarget.id as ConstraintsType;
- if (selection === ConstraintsType.NONE) {
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
+
+ editItemDefinition(itemDefinitionId, (itemDefinition) => {
+ if (selectedConstraint === ConstraintsType.NONE) {
itemDefinition.typeConstraint = undefined;
- });
- return;
- }
+ return;
+ }
- editItemDefinition(itemDefinitionId!, (itemDefinition) => {
- itemDefinition.typeConstraint ??= { text: { __$$text: "" } };
- const previousKieContraintType = itemDefinition.typeConstraint["@_kie:constraintType"];
- itemDefinition.typeConstraint["@_kie:constraintType"] = enumToKieConstraintType(selection);
+ if (itemDefinition.typeConstraint) {
+ itemDefinition.typeConstraint["@_kie:constraintType"] = enumToKieConstraintType(selectedConstraint);
+ }
- if (selection === ConstraintsType.EXPRESSION) {
+ if (selectedConstraint === ConstraintsType.EXPRESSION) {
return;
}
if (
- previousKieContraintType === "expression" &&
- selection === ConstraintsType.ENUMERATION &&
- isEnum(
- itemDefinition.typeConstraint.text.__$$text,
- constraintTypeHelper(
- (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
- ).check
- )
+ selectedConstraint === ConstraintsType.ENUMERATION &&
+ isEnum(itemDefinition.typeConstraint?.text.__$$text, typeRefConstraintTypeHelper.check)
) {
return;
}
if (
- previousKieContraintType === "expression" &&
- selection === ConstraintsType.RANGE &&
- isRange(
- itemDefinition.typeConstraint.text.__$$text,
- constraintTypeHelper(
- (itemDefinition?.typeRef?.__$$text as DmnBuiltInDataType) ?? DmnBuiltInDataType.Undefined
- ).check
- )
+ selectedConstraint === ConstraintsType.RANGE &&
+ isRange(itemDefinition.typeConstraint?.text.__$$text, typeRefConstraintTypeHelper.check)
) {
return;
}
- itemDefinition.typeConstraint.text.__$$text = "";
+ itemDefinition.typeConstraint = undefined;
});
},
- [editItemDefinition, enumToKieConstraintType, itemDefinitionId]
+ [editItemDefinition, itemDefinitionId, enumToKieConstraintType, typeRefConstraintTypeHelper.check]
);
return (
);
}
export function Constraints({
isReadonly,
- itemDefinition,
+ itemDefinitionId,
constraintValue,
+ typeHelper,
typeRef,
isConstraintEnum,
isConstraintRange,
isConstraintEnabled,
- selectedConstraint,
+ selectedKieConstraintType,
onToggleGroupChange,
onConstraintChange,
+ renderOnPropertiesPanel,
}: {
isReadonly: boolean;
- itemDefinition: DMN15__tItemDefinition;
+ itemDefinitionId: string;
constraintValue: string | undefined;
+ typeHelper: TypeHelper;
typeRef: DmnBuiltInDataType;
isConstraintEnum: string[] | undefined;
isConstraintRange: [string, string] | undefined;
@@ -618,13 +707,37 @@ export function Constraints({
range: boolean;
expression: boolean;
};
- selectedConstraint: ConstraintsType;
- onToggleGroupChange: (
- selected: boolean,
- event: React.KeyboardEvent | MouseEvent | React.MouseEvent
- ) => void;
- onConstraintChange: (value?: string) => void;
+ selectedKieConstraintType: ConstraintsType;
+ renderOnPropertiesPanel?: boolean;
+ onToggleGroupChange: (selected: boolean, selectedConstraint: ConstraintsType) => void;
+ onConstraintChange: (value: string | undefined, selectedConstraint: ConstraintsType) => void;
}) {
+ const [internalSelectedConstraint, setInternalSelectedConstraint] =
+ useState(selectedKieConstraintType);
+
+ // Updates the `selectedConstraint` only after changing the active item definition
+ // Both `internalSelectedConstraint` and `selectedKieConstraintType` should not be coupled together
+ useEffect(() => {
+ setInternalSelectedConstraint(selectedKieConstraintType);
+ // eslint-disable-next-line
+ }, [itemDefinitionId]);
+
+ const onToggleGroupChangeInternal = useCallback(
+ (selected: boolean, event: React.KeyboardEvent | MouseEvent | React.MouseEvent) => {
+ const selectedConstraint = event.currentTarget.id as ConstraintsType;
+ setInternalSelectedConstraint(selectedConstraint);
+ onToggleGroupChange(selected, selectedConstraint);
+ },
+ [onToggleGroupChange]
+ );
+
+ const onConstraintChangeInternal = useCallback(
+ (value: string | undefined) => {
+ onConstraintChange(value, internalSelectedConstraint);
+ },
+ [onConstraintChange, internalSelectedConstraint]
+ );
+
return (
<>
{isConstraintEnabled.expression === false &&
@@ -647,79 +760,105 @@ export function Constraints({
