@enjoys/context-engine 1.4.1 → 1.4.2

package/data/definition/flow9.json

@@ -151,6 +151,213 @@
       "description": "A Boolean type in Flow9 with two possible values: true and false. Supports logical operators && (and), || (or), and ! (not). Used in conditional expressions, filter predicates, and control flow statements.",
       "type": "class",
       "module": "Flow9 Runtime"
+    },
+    "list": {
+      "signature": "List<T>",
+      "description": "Immutable linked list. The primary collection type in Flow9.",
+      "type": "type",
+      "module": "ds/list",
+      "members": {
+        "Cons": {
+          "signature": "Cons(head: T, tail: List<T>)",
+          "description": "Constructs a list with a head element and a tail list.",
+          "type": "constructor"
+        },
+        "EmptyList": {
+          "signature": "EmptyList()",
+          "description": "The empty list.",
+          "type": "constructor"
+        }
+      }
+    },
+    "map": {
+      "signature": "map(a: [?], fn: (?) -> ??) -> [??]",
+      "description": "Applies fn to each element of array a and returns new array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[??]"
+    },
+    "filter": {
+      "signature": "filter(a: [?], fn: (?) -> bool) -> [?]",
+      "description": "Returns array of elements where fn returns true.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "fold": {
+      "signature": "fold(a: [?], init: ??, fn: (??, ?) -> ??) -> ??",
+      "description": "Left fold over an array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "??"
+    },
+    "iter": {
+      "signature": "iter(a: [?], fn: (?) -> void) -> void",
+      "description": "Iterates over each element of the array applying fn.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "void"
+    },
+    "iteri": {
+      "signature": "iteri(a: [?], fn: (int, ?) -> void) -> void",
+      "description": "Iterates over each element with its index.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "void"
+    },
+    "mapi": {
+      "signature": "mapi(a: [?], fn: (int, ?) -> ??) -> [??]",
+      "description": "Maps with index.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[??]"
+    },
+    "length": {
+      "signature": "length(a: [?]) -> int",
+      "description": "Returns the length of an array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "int"
+    },
+    "concat": {
+      "signature": "concat(a: [?], b: [?]) -> [?]",
+      "description": "Concatenates two arrays.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "sort": {
+      "signature": "sort(a: [?], cmp: (?, ?) -> int) -> [?]",
+      "description": "Sorts an array using the comparison function.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "exists": {
+      "signature": "exists(a: [?], fn: (?) -> bool) -> bool",
+      "description": "Returns true if any element satisfies the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "bool"
+    },
+    "forall": {
+      "signature": "forall(a: [?], fn: (?) -> bool) -> bool",
+      "description": "Returns true if all elements satisfy the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "bool"
+    },
+    "find": {
+      "signature": "find(a: [?], fn: (?) -> bool) -> Maybe<?>",
+      "description": "Finds the first element that satisfies the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "Maybe<?>"
+    },
+    "makeTree": {
+      "signature": "makeTree() -> Tree<?, ??>",
+      "description": "Creates an empty balanced binary tree (map).",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "setTree": {
+      "signature": "setTree(tree: Tree<?, ??>, key: ?, value: ??) -> Tree<?, ??>",
+      "description": "Inserts or updates a key-value pair in the balanced tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "lookupTree": {
+      "signature": "lookupTree(tree: Tree<?, ??>, key: ?) -> Maybe<??>",
+      "description": "Looks up a value by key in the balanced tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Maybe<??>"
+    },
+    "removeFromTree": {
+      "signature": "removeFromTree(tree: Tree<?, ??>, key: ?) -> Tree<?, ??>",
+      "description": "Removes a key-value pair from the tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "makeSet": {
+      "signature": "makeSet() -> Set<?>",
+      "description": "Creates an empty set.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "Set<?>"
+    },
+    "insertSet": {
+      "signature": "insertSet(set: Set<?>, val: ?) -> Set<?>",
+      "description": "Inserts a value into the set.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "Set<?>"
+    },
+    "containsSet": {
+      "signature": "containsSet(set: Set<?>, val: ?) -> bool",
+      "description": "Checks if the set contains the value.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "bool"
+    },
+    "println": {
+      "signature": "println(s: string) -> void",
+      "description": "Prints a string followed by a newline.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "void"
+    },
+    "i2s": {
+      "signature": "i2s(i: int) -> string",
+      "description": "Converts an integer to a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
+    },
+    "s2i": {
+      "signature": "s2i(s: string) -> int",
+      "description": "Converts a string to an integer.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "int"
+    },
+    "d2s": {
+      "signature": "d2s(d: double) -> string",
+      "description": "Converts a double to a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
+    },
+    "s2d": {
+      "signature": "s2d(s: string) -> double",
+      "description": "Converts a string to a double.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "double"
+    },
+    "strlen": {
+      "signature": "strlen(s: string) -> int",
+      "description": "Returns the length of a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "int"
+    },
+    "strContainsAt": {
+      "signature": "strContainsAt(s: string, pos: int, sub: string) -> bool",
+      "description": "Checks if s contains sub at position pos.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "bool"
+    },
+    "substring": {
+      "signature": "substring(s: string, start: int, len: int) -> string",
+      "description": "Returns a substring starting at start with length len.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
     }
   }
-}
+}

package/data/definition/freemarker2.json

@@ -171,6 +171,288 @@
       "description": "Defines a reusable template fragment (macro) with optional parameters and default values. Macros are called with the <@name> syntax and support nested content via <#nested>. They enable DRY template design by encapsulating repeated layout patterns.",
       "type": "keyword",
       "module": "FreeMarker Directives"
+    },
+    "if": {
+      "signature": "<#if condition>...</#if>",
+      "description": "Conditional directive. Evaluates and renders content if the condition is true.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "else": {
+      "signature": "<#else>",
+      "description": "Else branch of an if directive.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "elseif": {
+      "signature": "<#elseif condition>",
+      "description": "Else-if branch of an if directive.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "list": {
+      "signature": "<#list sequence as item>...</#list>",
+      "description": "Iterates over a sequence (array/collection). The most commonly used looping directive.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "assign": {
+      "signature": "<#assign name=value>",
+      "description": "Creates or replaces a variable in the current namespace.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "include": {
+      "signature": "<#include path>",
+      "description": "Processes a specified template and includes the output.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "import": {
+      "signature": "<#import path as namespace>",
+      "description": "Imports a library and assigns it to a namespace variable.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "macro": {
+      "signature": "<#macro name param1 param2>...</#macro>",
+      "description": "Defines a macro (reusable template fragment) with parameters.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "function": {
+      "signature": "<#function name param1 param2>...<#return value></#function>",
+      "description": "Defines a function that returns a value.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "switch": {
+      "signature": "<#switch value><#case refValue>...<#break><#default>...</#switch>",
+      "description": "Multi-branch selection based on value comparison.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "attempt": {
+      "signature": "<#attempt>...<#recover>...</#attempt>",
+      "description": "Error handling. Renders recover block if attempt fails.",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "setting": {
+      "signature": "<#setting name=value>",
+      "description": "Sets FreeMarker engine settings (locale, number_format, date_format, etc.).",
+      "type": "directive",
+      "module": "FreeMarker"
+    },
+    "interpolation": {
+      "signature": "${expression}",
+      "description": "Outputs the value of an expression. The primary output mechanism.",
+      "type": "syntax",
+      "module": "FreeMarker"
+    },
+    "?string": {
+      "signature": "value?string",
+      "description": "Converts a value to a string representation.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?number": {
+      "signature": "value?number",
+      "description": "Converts a string to a number.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?size": {
+      "signature": "sequence?size",
+      "description": "Returns the number of elements in a sequence or hash.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?has_content": {
+      "signature": "value?has_content",
+      "description": "Returns true if the value is not null, not empty, and not a blank string.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?upper_case": {
+      "signature": "string?upper_case",
+      "description": "Converts the string to upper case.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?lower_case": {
+      "signature": "string?lower_case",
+      "description": "Converts the string to lower case.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?trim": {
+      "signature": "string?trim",
+      "description": "Removes leading and trailing whitespace.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?replace": {
+      "signature": "string?replace(what, with)",
+      "description": "Replaces all occurrences of a substring.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?split": {
+      "signature": "string?split(separator)",
+      "description": "Splits a string into a sequence by separator.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?starts_with": {
+      "signature": "string?starts_with(prefix)",
+      "description": "Returns true if the string starts with the given prefix.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?contains": {
+      "signature": "string?contains(substring)",
+      "description": "Returns true if the string contains the given substring.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?index_of": {
+      "signature": "string?index_of(substring)",
+      "description": "Returns the index of the first occurrence of substring, or -1.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?length": {
+      "signature": "string?length",
+      "description": "Returns the length of the string.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?first": {
+      "signature": "sequence?first",
+      "description": "Returns the first element of a sequence.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?last": {
+      "signature": "sequence?last",
+      "description": "Returns the last element of a sequence.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?sort_by": {
+      "signature": "sequence?sort_by(key)",
+      "description": "Returns the sequence sorted by the specified sub-variable.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?filter": {
+      "signature": "sequence?filter(item -> condition)",
+      "description": "Returns a new sequence containing only elements for which the condition is true.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?map": {
+      "signature": "sequence?map(item -> expression)",
+      "description": "Returns a new sequence where each element is the result of the expression.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?join": {
+      "signature": "sequence?join(separator)",
+      "description": "Concatenates elements of a sequence into a string with the given separator.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?keys": {
+      "signature": "hash?keys",
+      "description": "Returns a sequence containing all keys of the hash.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?values": {
+      "signature": "hash?values",
+      "description": "Returns a sequence containing all values of the hash.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?date": {
+      "signature": "value?date",
+      "description": "Converts a value to a date.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?datetime": {
+      "signature": "value?datetime",
+      "description": "Converts a value to a date-time.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?html": {
+      "signature": "string?html",
+      "description": "HTML-encodes the string (escapes <, >, &, \").",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?url": {
+      "signature": "string?url",
+      "description": "URL-encodes the string.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?j_string": {
+      "signature": "string?j_string",
+      "description": "Escapes the string for use in a Java or JavaScript string literal.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?json_string": {
+      "signature": "string?json_string",
+      "description": "Escapes the string for use in a JSON string value.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?is_string": {
+      "signature": "value?is_string",
+      "description": "Returns true if the value is a string.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?is_number": {
+      "signature": "value?is_number",
+      "description": "Returns true if the value is a number.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?is_boolean": {
+      "signature": "value?is_boolean",
+      "description": "Returns true if the value is a boolean.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?is_sequence": {
+      "signature": "value?is_sequence",
+      "description": "Returns true if the value is a sequence.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "?is_hash": {
+      "signature": "value?is_hash",
+      "description": "Returns true if the value is a hash.",
+      "type": "builtin",
+      "module": "FreeMarker"
+    },
+    "??": {
+      "signature": "value??",
+      "description": "Missing value test operator. Returns true if the variable exists and is not null.",
+      "type": "operator",
+      "module": "FreeMarker"
+    },
+    "!": {
+      "signature": "value!default",
+      "description": "Default value operator. Returns default if value is missing.",
+      "type": "operator",
+      "module": "FreeMarker"
     }
   }
-}
+}