@bpmnkit/camunda-docspack 0.0.0

package/.llms/chunks/components.modeler.feel.language-guide.feel-context-expressions.md

@@ -0,0 +1,151 @@
+# Context expressions
+
+Learn more about how you can use FEEL context expressions, including examples that show common use cases for FEEL context expressions.
+
+You can use the following FEEL context expressions. Examples are provided to show common use cases.
+
+### Literal
+
+Creates a new context with the given entries.
+
+- Each entry has a key and a value.
+- The key is either a name or a string.
+- The value can be any type.
+
+**Info**
+For valid key names, see [naming conventions](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-variables#variable-names).
+
+```feel
+{
+  a: 1,
+  b: 2
+}
+// {a:1, b:2}
+
+{
+  "a": 1,
+  "b": 2
+}
+// {a:1, b:2}
+```
+
+Inside the context, the previous entries can be accessed.
+
+```feel
+{
+  a: 2,
+  b: a * 2
+}
+// {a:2, b:4}
+```
+
+A context value can embed other context values.
+
+```feel
+{
+  a: 1,
+  b: {
+    c: 2
+  }
+}
+// {a:1, b:{c:2}}
+```
+
+### Get entry/path
+
+```feel
+a.b
+```
+
+Accesses the entry with the key `b` of the context `a`. The path is separated by a dot `.`.
+
+If the value of the entry `b` is also a context, the path can be chained (i.e. `a.b.c`).
+
+```feel
+{a: 2}.a
+// 2
+
+{a: {b: 3}}.a
+// {b: 3}
+
+{a: {b: 3}}.a.b
+// 3
+```
+
+If the context `a` doesn't contain an entry with the key `b`, the expression returns `null`.
+
+```feel
+{a: 1}.b
+// null
+
+{a: 1}.b.c
+// null
+```
+
+### Filter
+
+```feel
+a[c]
+```
+
+Filters the list of context elements `a` by the condition `c`. The result of the expression is a
+list that contains all elements where the condition `c` evaluates to `true`. The other elements are
+excluded.
+
+While filtering, the current element is assigned to the variable `item` and its entries can be
+accessed by their key.
+
+```feel
+[
+  {
+    a: "p1",
+    b: 5
+  },
+  {
+    a: "p2",
+    b: 10
+  }
+][b > 7]
+// [{a: "p2", b: 10}]
+```
+
+### Projection
+
+```feel
+a.b
+```
+
+Extracts the entries with the key `b` of the list of context elements `a` (that is, a projection). It returns a list containing the values of the context elements with the key `b`.
+
+```feel
+[
+  {
+    a: "p1",
+    b: 5
+  },
+  {
+    a: "p2",
+    b: 10
+  }
+].a
+// ["p1", "p2"]
+```
+
+If an element of the list `a` doesn't contain an entry with the key `b`, the result contains `null` of this element.
+
+```feel
+[
+  {
+    a: "p1",
+    b: 5
+  },
+  {
+    a: "p2",
+    c: 20
+  }
+].b
+// [5, null]
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-context-expressions

package/.llms/chunks/components.modeler.feel.language-guide.feel-control-flow.md

@@ -0,0 +1,77 @@
+# Control flow
+
+This document outlines control flow and examples.
+
+### If conditions
+
+```feel
+if c then a else b
+```
+
+Executes the expression `a` if the condition `c` evaluates to `true`. Otherwise, it executes the
+expression `b`.
+
+```feel
+if 5 < 10  then "low" else "high"
+// "low"
+
+if 12 < 10 then "low" else "high"
+// "high"
+```
+
+**Info: good to know**
+If the condition `c` doesn't evaluate to a boolean value (e.g. `null`), it
+executes the expression `b`.
+
+```feel
+if null then "low" else "high"
+// "high"
+```
+
+### For loops
+
+```feel
+for a in b return c
+```
+
+Iterates over the list `b` and executes the expression `c` for each element in the list. The current
+element is assigned to the variable `a`. The result of the expression is a list.
+
+If multiple lists are passed to the `for` loop then it iterates over the cross-product of the
+elements in the given lists.
+
+```feel
+for x in [1,2,3] return x * 2
+// [2,4,6]
+
+for x in [1,2], y in [3,4] return x * y
+// [3, 4, 6, 8]
+```
+
+While iterating over the list, the previous elements are assigned to the variable `partial`.
+
+```feel
+for i in 1..10 return if (i <= 2) then 1 else partial[-1] + partial[-2]
+// [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+```
+
+**Tip**
+The variable `partial` can be used to retrieve the index of the current element.
+
+```feel
+for x in ["a","b","c"] return {value: x, index: count(partial) + 1}
+// [{"value":"a","index":1},{"value":"b","index":2},{"value":"c","index":3}]
+```
+
+Instead of a list, the `for` loop can also iterate over a given range.
+
+```feel
+for x in 0..8 return 2 ** x
+// [1, 2, 4, 8, 16, 32, 64, 128, 256]
+
+for x in 3..1 return 2 * x
+// [6,4,2]
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-control-flow

package/.llms/chunks/components.modeler.feel.language-guide.feel-data-types.md

@@ -0,0 +1,183 @@
+# Data types
+
+This document outlines data types, including null, number, string, boolean, and more.
+
+FEEL defines the following types:
+
+### Null
+
+Nothing, null, or nil (i.e. the value is not present).
+
+- Java Type: `null`
+
+```feel
+null
+```
+
+### Number
+
+A whole or floating point number. The number can be negative.
+
+- not-a-number (NaN), positive/negative infinity are represented as `null`
+- Java Type: `java.math.BigDecimal`
+
+```feel
+1
+
+2.3
+
+.4
+
+-5
+```
+
+### String
+
+A sequence of characters enclosed in double quotes `"`. The sequence can contain escaped characters starting with
+`\` (e.g. `\'`, `\"`, `\\`, `\n`, `\r`, `\t`, Unicode like `\u269D` or `\U101EF`) and can span multiple lines.
+
+- Java Type: `java.lang.String`
+
+```feel
+"valid"
+```
+
+### Boolean
+
+A boolean value. It is either true or false.
+
+- Java Type: `java.lang.Boolean`
+
+```feel
+true
+
+false
+```
+
+### Date
+
+A date value without a time component.
+
+- Format: `yyyy-MM-dd`.
+- Java Type: `java.time.LocalDate`
+
+```feel
+date("2017-03-10")
+
+@"2017-03-10"
+```
+
+### Time
+
+A local or zoned time. The time can have an optional timezone offset. The usage of a time zone ID is deprecated because
+it can lead to ambiguous results without a date component.
+
+- Format: `HH:mm:ss` / `HH:mm:ss+/-HH:mm`
+- Java Type: `java.time.LocalTime` / `java.time.OffsetTime`
+
+```feel
+time("11:45:30")
+time("13:30")
+time("11:45:30+02:00")
+
+@"11:45:30"
+@"13:30"
+@"11:45:30+02:00"
+```
+
+### Date-time
+
+A date with a local or zoned time component. The time can have an offset or time zone ID.
+
+- Formats:
+  - `yyyy-MM-dd'T'HH:mm:ss`
+  - `yyyy-MM-dd'T'HH:mm:ssZ`
+  - `yyyy-MM-dd'T'HH:mm:ss+/-HH:mm`
+  - `yyyy-MM-dd'T'HH:mm:ss@ZoneId`
+  - `yyyy-MM-dd'T'HH:mm:ss+/-HH:mm[ZoneId]`
+- Java Type: `java.time.LocalDateTime` / `java.time.DateTime`
+
+```feel
+date and time("2015-09-18T10:31:10")
+date and time("2015-09-18T10:31:10Z")
+date and time("2015-09-18T10:31:10+01:00")
+date and time("2015-09-18T10:31:10@Europe/Paris")
+date and time("2015-09-18T10:31:10+02:00[Europe/Paris]")
+
+@"2015-09-18T10:31:10"
+@"2015-09-18T10:31:10Z"
+@"2015-09-18T10:31:10+01:00"
+@"2015-09-18T10:31:10@Europe/Paris"
+@"2015-09-18T10:31:10+02:00[Europe/Paris]"
+```
+
+### Days-time-duration
+
+A duration based on seconds. It can contain days, hours, minutes, and seconds.
+
+- Format: `PxDTxHxMxS`
+- Java Type: `java.time.Duration`
+
+```feel
+duration("P4D")
+duration("PT2H")
+duration("PT30M")
+duration("P1DT6H")
+
+@"P4D"
+@"PT2H"
+@"PT30M"
+@"P1DT6H"
+```
+
+### Years-months-duration
+
+A duration based on the calendar. It can contain years and months.
+
+- Format: `PxYxM`
+- Java Type: `java.time.Period`
+
+```feel
+duration("P2Y")
+duration("P6M")
+duration("P1Y6M")
+
+@"P2Y"
+@"P6M"
+@"P1Y6M"
+```
+
+### List
+
+A list of elements. The elements can be of any type. The list can be empty.
+
+- Java Type: `java.util.List`
+
+```feel
+[]
+[1,2,3]
+["a","b"]
+
+[["list"], "of", [["lists"]]]
+```
+
+### Context
+
+A list of entries. Each entry has a key and a value. The key is either a name or a string. The value
+can be any type. The context can be empty.
+
+- Java Type: `java.util.Map`
+
+```feel
+{}
+
+{a:1}
+{b: 2, c: "valid"}
+{nested: {d: 3}}
+
+{"a": 1}
+{"b": 2, "c": "valid"}
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-data-types

package/.llms/chunks/components.modeler.feel.language-guide.feel-error-handling.md

@@ -0,0 +1,61 @@
+# Error handling
+
+This document outlines the error handling.
+
+FEEL doesn't define any error handling. Instead, it follows one simple rule: if something
+goes wrong, return `null`.
+
+### Null-friendly
+
+If an expression can't be evaluated successfully, it returns `null`.
+
+For example, in the following cases:
+
+- No variable exists with the given name
+- No context entry exists with the given key
+- No function exists with the given name
+- A function can't be invoked successfully with the given arguments
+- A value is compared to another value of a different type
+- An operation is not defined for the given values
+
+### Handle null values
+
+Expressions and operators can deal with `null` values. In many cases, they result also in `null`.
+
+```feel
+a.b > 10
+// null
+
+[{a: 1}, {b: 2}].a
+// [1, null]
+
+[{a: 1}, {b: 2}][a < 10]
+// [{a: 1}]
+```
+
+To handle `null` values explicitly, use
+a [null-check](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-boolean-expressions#null-check) or the
+function [`get or else()`](https://docs.camunda.io/docs/next/components/modeler/feel/builtin-functions/feel-built-in-functions-boolean#get-or-elsevalue-default).
+
+```feel
+a != null and a.b > 10
+
+get or else(a, "prio-99")
+```
+
+### Assertions
+
+By default, the evaluation of an expression doesn't fail but returns `null`. If there is a special need to fail the
+evaluation under a certain condition, use the
+function [`assert()`](https://docs.camunda.io/docs/next/components/modeler/feel/builtin-functions/feel-built-in-functions-boolean#assertvalue-condition).
+
+```feel
+assert(a, a != null)
+// returns a if a is not null
+// fails if a is null
+
+assert(b, b >= 0, "'b' should be positive")
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-error-handling

package/.llms/chunks/components.modeler.feel.language-guide.feel-expressions-introduction.md

@@ -0,0 +1,55 @@
+# Introduction
+
+FEEL expressions are powerful and can be used for various cases.
+
+FEEL expressions are powerful and can be used for various cases.
+
+This section is split into expressions based on their operational data type:
+
+- [Boolean](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-boolean-expressions)
+- [String](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-string-expressions)
+- [Numeric](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-numeric-expressions)
+- [List](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-list-expressions)
+- [Context](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-context-expressions)
+- [Temporal](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-temporal-expressions)
+
+The following sections cover more general areas that are not restricted to one data type:
+
+- [Variables](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-variables)
+- [Control flow](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-control-flow)
+- [Functions](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-functions)
+- [Error handling](https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-error-handling)
+
+### Comments
+
+An expression can contain comments to explain it and give it more context. This can be done using
+Java-style comments: `//` to the end of line, or `/*.... */` for blocks.
+
+```feel
+// returns the last item
+[1,2,3,4][-1]
+
+/* returns the last item */
+[1,2,3,4][-1]
+
+/*
+ * returns the last item
+ */
+[1,2,3,4][-1]
+```
+
+### Parentheses
+
+Parentheses `( .. )` can be used in expressions to separate different parts of an
+expression or to influence the precedence of the operators.
+
+```feel
+(5 - 3) * (4 / 2)
+
+x < 5 and (y > 10 or z > 20)
+
+if (5 < 10) then "low" else "high"
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-expressions-introduction

package/.llms/chunks/components.modeler.feel.language-guide.feel-functions.md

@@ -0,0 +1,44 @@
+# Functions
+
+This document outlines various functions and examples.
+
+### Invocation
+
+Invokes a built-in function (e.g. [`contains()`](https://docs.camunda.io/docs/next/components/modeler/feel/builtin-functions/feel-built-in-functions-string#containsstring-match)) or a user-defined
+function by its name. The arguments of the function can be passed positional or named.
+
+- Positional: Only the values, in the same order as defined by the function (e.g. `f(1,2)`).
+- Named: The values with the argument name as prefix, in any order (e.g. `f(a: 1, b: 2)`).
+
+```feel
+contains("me@camunda.com", ".com")
+// true
+
+contains(string: "me@camunda.com", match: ".de")
+// false
+```
+
+**Info: GOOD TO KNOW**
+
+The invocation returns `null` if no function exists with the given name, or if the argument
+types don't match the function signature.
+
+### User-defined
+
+```feel
+function(a,b) e
+```
+
+Defines a function with a list of argument names, and an expression (i.e. the function body). When
+the function is invoked, it assigns the values to the arguments and evaluates the expression.
+
+Within an expression, a function can be defined and invoked in a context.
+
+```feel
+{
+  age: function(birthday) (today() - birthday).years
+}
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-functions

package/.llms/chunks/components.modeler.feel.language-guide.feel-list-expressions.examples.md

@@ -0,0 +1,91 @@
+# List expressions — Examples
+
+### Filter list and return the first element
+
+Return the first packaging element which unit is "Palette".
+
+```feel
+data.attribute.packaging[unit = "Palette"][1]
+```
+
+### Group list
+
+Group the given list of invoices by their person.
+
+Each invoice has a person. The persons are extracted from the invoices and are used as a filter for the list.
+
+```feel
+for p in distinct values(invoices.person) return invoices[person = p]
+```
+
+#### Evaluation context
+
+```feel
+{"invoices":[
+  {"id":1, "person":"A", "amount": 10},
+  {"id":2, "person":"A", "amount": 20},
+  {"id":3, "person":"A", "amount": 30},
+  {"id":4, "person":"A", "amount": 40},
+  {"id":5, "person":"B", "amount": 15},
+  {"id":6, "person":"B", "amount": 25}
+]}
+```
+
+#### Evaluation result
+
+```feel
+[
+  [
+    { id: 1, person: "A", amount: 10 },
+    { id: 2, person: "A", amount: 20 },
+    { id: 3, person: "A", amount: 30 },
+    { id: 4, person: "A", amount: 40 },
+  ],
+  [
+    { id: 5, person: "B", amount: 15 },
+    { id: 6, person: "B", amount: 25 },
+  ],
+]
+```
+
+### Merge two lists
+
+Merge two given lists. Each list contains context values with the same structure. Each context has an `id` entry that identifies the value.
+
+The result is a list that contains all context values grouped by the identifier.
+
+```feel
+ {
+   ids: union(x.files.id,y.files.id),
+   getById: function (files,fileId) get or else(files[id=fileId][1], {}),
+   merge: for id in ids return context merge(getById(x.files, id), getById(y.files, id))
+ }.merge
+```
+
+#### Evaluation context
+
+```feel
+{
+ "x": {"files": [
+   {"id":1, "content":"a"},
+   {"id":2, "content":"b"}
+ ]},
+ "y": {"files": [
+   {"id":1, "content":"a2"},
+   {"id":3, "content":"c"}
+ ]}
+}
+```
+
+#### Evaluation result
+
+```feel
+[
+  { id: 1, content: "a2" },
+  { id: 2, content: "b" },
+  { id: 3, content: "c" },
+]
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/feel/language-guide/feel-list-expressions