@enjoys/context-engine 1.1.0 → 1.1.2

package/data/defination/msdax.json

@@ -0,0 +1,125 @@
+{
+  "language": "msdax",
+  "definitions": {
+    "CALCULATE": {
+      "signature": "CALCULATE(expression, filter1, filter2, ...) -> Scalar",
+      "description": "Evaluates an expression in a modified filter context created by applying zero or more filter arguments. The most important DAX function, enabling context transition and dynamic measure recalculation.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "FILTER": {
+      "signature": "FILTER(table, filter_expression) -> Table",
+      "description": "Returns a table that represents a subset of another table or expression, containing only rows where the filter expression evaluates to TRUE. Commonly used inside CALCULATE and iterator functions.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "ALL": {
+      "signature": "ALL(table_or_column, ...) -> Table",
+      "description": "Returns all rows in a table or all values in a column, ignoring any filters that have been applied. Essential for calculating ratios, percentages, and grand totals against the unfiltered dataset.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "ALLEXCEPT": {
+      "signature": "ALLEXCEPT(table, column1, column2, ...) -> Table",
+      "description": "Removes all context filters from the specified table except for the filters on the listed columns, enabling subtotal calculations that preserve certain dimensional groupings.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "RELATED": {
+      "signature": "RELATED(column) -> Scalar",
+      "description": "Returns a related value from another table using an established relationship. Follows many-to-one relationships to retrieve a single value from the lookup table for each row context.",
+      "type": "function",
+      "module": "Relationship"
+    },
+    "RELATEDTABLE": {
+      "signature": "RELATEDTABLE(table) -> Table",
+      "description": "Returns a table of rows related to the current row context by following one-to-many relationships, equivalent to CALCULATETABLE with the related table applying row context as filter.",
+      "type": "function",
+      "module": "Relationship"
+    },
+    "SUMX": {
+      "signature": "SUMX(table, expression) -> Scalar",
+      "description": "Iterates over each row of the specified table and evaluates the expression, then returns the sum of all evaluated values. Enables row-by-row calculations before aggregation.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "AVERAGEX": {
+      "signature": "AVERAGEX(table, expression) -> Scalar",
+      "description": "Iterates over each row of the specified table and evaluates the expression, then returns the arithmetic mean of all evaluated values. Blank values are excluded from the calculation.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "COUNTROWS": {
+      "signature": "COUNTROWS(table) -> Integer",
+      "description": "Counts the number of rows in the specified table or table expression, including rows with blank values. Returns a whole number representing the row count of the evaluated table.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "VALUES": {
+      "signature": "VALUES(column_or_table) -> Table",
+      "description": "Returns a one-column table of distinct values from the specified column in the current filter context, including the blank row added for referential integrity violations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "EARLIER": {
+      "signature": "EARLIER(column, number) -> Scalar",
+      "description": "Returns the value of the specified column in an outer row context when nested row contexts exist, commonly used in calculated columns to compare current row values against outer iterations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "DIVIDE": {
+      "signature": "DIVIDE(numerator, denominator, alternate_result) -> Scalar",
+      "description": "Performs safe division of numerator by denominator, returning the alternate result (default BLANK) when the denominator is zero, avoiding division-by-zero errors in measures.",
+      "type": "function",
+      "module": "Math"
+    },
+    "IF": {
+      "signature": "IF(logical_test, value_if_true, value_if_false) -> Scalar",
+      "description": "Evaluates a logical condition and returns one of two values based on whether the condition is TRUE or FALSE, supporting conditional logic in calculated columns and measures.",
+      "type": "function",
+      "module": "Logical"
+    },
+    "SWITCH": {
+      "signature": "SWITCH(expression, value1, result1, ..., else_result) -> Scalar",
+      "description": "Evaluates an expression against a list of values and returns the corresponding result, or an optional else result. More readable than nested IF statements for multi-condition logic.",
+      "type": "function",
+      "module": "Logical"
+    },
+    "SELECTEDVALUE": {
+      "signature": "SELECTEDVALUE(column, alternate_result) -> Scalar",
+      "description": "Returns the value when the filter context for the column has been filtered down to a single distinct value, otherwise returns the alternate result or BLANK for slicer-driven calculations.",
+      "type": "function",
+      "module": "Filter"
+    },
+    "DATEADD": {
+      "signature": "DATEADD(dates, number_of_intervals, interval) -> Table",
+      "description": "Returns a table of dates shifted by the specified number of intervals (DAY, MONTH, QUARTER, YEAR) from the dates in the current filter context, enabling period-over-period time intelligence.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "TOTALYTD": {
+      "signature": "TOTALYTD(expression, dates, filter, year_end_date) -> Scalar",
+      "description": "Evaluates a year-to-date total for the given expression over the specified date column, optionally with a custom fiscal year-end date and additional filters for time intelligence.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "SAMEPERIODLASTYEAR": {
+      "signature": "SAMEPERIODLASTYEAR(dates) -> Table",
+      "description": "Returns a table containing a column of dates shifted one year back from the dates in the current filter context, commonly used within CALCULATE for year-over-year comparison measures.",
+      "type": "function",
+      "module": "Time Intelligence"
+    },
+    "RANKX": {
+      "signature": "RANKX(table, expression, value, order, ties) -> Integer",
+      "description": "Returns the ranking of a value in a table for the given expression, with configurable sort order (ASC or DESC) and tie-breaking behavior for SKIP or DENSE ranking.",
+      "type": "function",
+      "module": "Aggregation"
+    },
+    "ISBLANK": {
+      "signature": "ISBLANK(value) -> Boolean",
+      "description": "Returns TRUE if the specified value is BLANK, the special DAX empty state. Useful for handling missing data, null values, and referential integrity gaps in data models.",
+      "type": "function",
+      "module": "Information"
+    }
+  }
+}

package/data/defination/mysql.json

@@ -0,0 +1,149 @@
+{
+  "language": "mysql",
+  "definitions": {
+    "CONCAT": {
+      "signature": "CONCAT(str1, str2, ...) -> VARCHAR",
+      "description": "Concatenates two or more string arguments into a single string. Returns NULL if any argument is NULL. For NULL-safe concatenation, use CONCAT_WS or IFNULL wrappers.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "CONCAT_WS": {
+      "signature": "CONCAT_WS(separator, str1, str2, ...) -> VARCHAR",
+      "description": "Concatenates strings with a separator between each pair, automatically skipping NULL values. The first argument is the delimiter used between the remaining arguments.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "SUBSTRING": {
+      "signature": "SUBSTRING(str, pos, len) -> VARCHAR",
+      "description": "Extracts a substring from the given string starting at position pos (1-based) for len characters. Negative pos counts from the end. Also aliased as SUBSTR and MID.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "REPLACE": {
+      "signature": "REPLACE(str, from_str, to_str) -> VARCHAR",
+      "description": "Returns a string with all occurrences of from_str replaced by to_str in the original string. The search is case-sensitive and does not support regular expressions.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "LENGTH": {
+      "signature": "LENGTH(str) -> INT",
+      "description": "Returns the length of the string in bytes. For multi-byte character sets use CHAR_LENGTH instead, which returns the number of characters regardless of encoding.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "NOW": {
+      "signature": "NOW() -> DATETIME",
+      "description": "Returns the current date and time as a DATETIME value in YYYY-MM-DD HH:MM:SS format. The value is determined at statement execution start and remains constant within the statement.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "CURDATE": {
+      "signature": "CURDATE() -> DATE",
+      "description": "Returns the current date as a DATE value in YYYY-MM-DD format without the time component. Equivalent to CURRENT_DATE and useful for date-only comparisons and filters.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATE_FORMAT": {
+      "signature": "DATE_FORMAT(date, format) -> VARCHAR",
+      "description": "Formats a date value according to the specified format string using specifiers like %Y for 4-digit year, %m for month, %d for day, %H for hour, %i for minute, %s for second.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATEDIFF": {
+      "signature": "DATEDIFF(date1, date2) -> INT",
+      "description": "Returns the number of days between two date or datetime expressions, calculated as date1 minus date2. Only the date parts are used in the calculation, ignoring time components.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATE_ADD": {
+      "signature": "DATE_ADD(date, INTERVAL value unit) -> DATE/DATETIME",
+      "description": "Adds a time interval to a date or datetime value. Units include SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR, and compound units like DAY_HOUR.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "IF": {
+      "signature": "IF(condition, value_if_true, value_if_false) -> ANY",
+      "description": "Evaluates a boolean condition and returns the second argument if true or the third argument if false. A concise inline conditional expression for SELECT lists and computed columns.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "IFNULL": {
+      "signature": "IFNULL(expr1, expr2) -> ANY",
+      "description": "Returns expr1 if it is not NULL, otherwise returns expr2. A concise NULL-handling function commonly used to provide default values for potentially NULL columns or expressions.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "COALESCE": {
+      "signature": "COALESCE(value1, value2, ...) -> ANY",
+      "description": "Returns the first non-NULL value in the argument list, or NULL if all arguments are NULL. Standard SQL function for cascading fallback values across multiple nullable expressions.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "CASE": {
+      "signature": "CASE expr WHEN val THEN result ELSE default END -> ANY",
+      "description": "Provides conditional logic in SQL expressions with two forms: simple comparing an expression to values, and searched evaluating boolean conditions. Returns the matching or ELSE result.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "COUNT": {
+      "signature": "COUNT(expr) -> BIGINT",
+      "description": "Aggregate function that returns the number of non-NULL values in the expression. COUNT(*) counts all rows including NULLs. COUNT(DISTINCT expr) counts unique non-NULL values.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "SUM": {
+      "signature": "SUM(expr) -> DECIMAL/DOUBLE",
+      "description": "Aggregate function that returns the sum of all non-NULL values in the expression. Returns NULL if there are no matching rows. Works with numeric types and implicit conversion.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "AVG": {
+      "signature": "AVG(expr) -> DOUBLE",
+      "description": "Aggregate function that returns the arithmetic mean of non-NULL values in the expression. NULL values are excluded from both the sum and count used in the average calculation.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "GROUP_CONCAT": {
+      "signature": "GROUP_CONCAT([DISTINCT] expr [ORDER BY col] [SEPARATOR str]) -> VARCHAR",
+      "description": "Aggregate function that concatenates values from multiple rows into a single string, with optional DISTINCT filtering, ORDER BY sorting, and custom SEPARATOR (default comma).",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "JSON_EXTRACT": {
+      "signature": "JSON_EXTRACT(json_doc, path[, path ...]) -> JSON",
+      "description": "Extracts data from a JSON document at the specified JSONPath expression. Returns NULL if the path does not exist. The ->> operator unquotes the result to a string.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "JSON_OBJECT": {
+      "signature": "JSON_OBJECT(key, value[, key, value ...]) -> JSON",
+      "description": "Creates a JSON object from the specified key-value pairs. Keys must be strings and are automatically quoted. Values are converted to appropriate JSON types.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "JSON_ARRAYAGG": {
+      "signature": "JSON_ARRAYAGG(expr) -> JSON",
+      "description": "Aggregate function that collects values from multiple rows into a JSON array. Preserves NULL values as JSON null elements within the resulting array output.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "CAST": {
+      "signature": "CAST(expr AS type) -> type",
+      "description": "Converts an expression to the specified data type. Supported target types include CHAR, DATE, DATETIME, DECIMAL, SIGNED, UNSIGNED, BINARY, JSON, and spatial types.",
+      "type": "function",
+      "module": "Cast Functions"
+    },
+    "ROW_NUMBER": {
+      "signature": "ROW_NUMBER() OVER (PARTITION BY col ORDER BY col) -> BIGINT",
+      "description": "Window function that assigns a unique sequential integer to each row within its partition, ordered by the specified columns. Available in MySQL 8.0+ for ranking and pagination.",
+      "type": "function",
+      "module": "Window Functions"
+    },
+    "RANK": {
+      "signature": "RANK() OVER (PARTITION BY col ORDER BY col) -> BIGINT",
+      "description": "Window function that assigns a rank to each row within its partition with gaps for ties. Equal values receive the same rank, and the next rank skips accordingly.",
+      "type": "function",
+      "module": "Window Functions"
+    }
+  }
+}

package/data/defination/objective-c.json

@@ -0,0 +1,217 @@
+{
+  "language": "objective-c",
+  "definitions": {
+    "NSString": {
+      "signature": "@interface NSString : NSObject",
+      "description": "The fundamental immutable string class in Foundation framework, representing Unicode text with rich manipulation capabilities. NSString objects are created using @\"literal\" syntax or factory methods.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "length": {
+          "signature": "@property (readonly) NSUInteger length",
+          "description": "Returns the number of UTF-16 code units in the string.",
+          "type": "method"
+        },
+        "stringByAppendingString:": {
+          "signature": "- (NSString *)stringByAppendingString:(NSString *)aString",
+          "description": "Returns a new string made by appending the given string to the receiver.",
+          "type": "method"
+        },
+        "substringWithRange:": {
+          "signature": "- (NSString *)substringWithRange:(NSRange)range",
+          "description": "Returns a string containing characters within the specified range.",
+          "type": "method"
+        },
+        "isEqualToString:": {
+          "signature": "- (BOOL)isEqualToString:(NSString *)aString",
+          "description": "Compares the receiver with the given string for Unicode equality.",
+          "type": "method"
+        },
+        "stringWithFormat:": {
+          "signature": "+ (instancetype)stringWithFormat:(NSString *)format, ...",
+          "description": "Creates a new string using a format string and arguments, similar to sprintf.",
+          "type": "method"
+        },
+        "componentsSeparatedByString:": {
+          "signature": "- (NSArray<NSString *> *)componentsSeparatedByString:(NSString *)separator",
+          "description": "Splits the string into substrings at each occurrence of the separator.",
+          "type": "method"
+        }
+      }
+    },
+    "NSArray": {
+      "signature": "@interface NSArray<ObjectType> : NSObject",
+      "description": "An ordered immutable collection of objects in Foundation framework, created using @[] literal syntax. Elements are accessed by zero-based index and must be Objective-C objects, not primitive types.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "count": {
+          "signature": "@property (readonly) NSUInteger count",
+          "description": "Returns the number of objects in the array.",
+          "type": "method"
+        },
+        "objectAtIndex:": {
+          "signature": "- (ObjectType)objectAtIndex:(NSUInteger)index",
+          "description": "Returns the object at the specified index, raising NSRangeException if out of bounds.",
+          "type": "method"
+        },
+        "containsObject:": {
+          "signature": "- (BOOL)containsObject:(ObjectType)anObject",
+          "description": "Returns YES if the array contains an object equal to the given object.",
+          "type": "method"
+        },
+        "enumerateObjectsUsingBlock:": {
+          "signature": "- (void)enumerateObjectsUsingBlock:(void (^)(ObjectType obj, NSUInteger idx, BOOL *stop))block",
+          "description": "Iterates over all objects in the array, executing the block for each element.",
+          "type": "method"
+        },
+        "filteredArrayUsingPredicate:": {
+          "signature": "- (NSArray<ObjectType> *)filteredArrayUsingPredicate:(NSPredicate *)predicate",
+          "description": "Returns a new array containing only elements that match the given predicate.",
+          "type": "method"
+        }
+      }
+    },
+    "NSDictionary": {
+      "signature": "@interface NSDictionary<KeyType, ObjectType> : NSObject",
+      "description": "An immutable collection of key-value pairs in Foundation framework, created using @{} literal syntax. Keys must conform to NSCopying protocol and are typically NSString objects.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "count": {
+          "signature": "@property (readonly) NSUInteger count",
+          "description": "Returns the number of key-value pairs in the dictionary.",
+          "type": "method"
+        },
+        "objectForKey:": {
+          "signature": "- (ObjectType)objectForKey:(KeyType)aKey",
+          "description": "Returns the value associated with the given key, or nil if not found.",
+          "type": "method"
+        },
+        "allKeys": {
+          "signature": "@property (readonly, copy) NSArray<KeyType> *allKeys",
+          "description": "Returns an array containing all keys in the dictionary.",
+          "type": "method"
+        },
+        "allValues": {
+          "signature": "@property (readonly, copy) NSArray<ObjectType> *allValues",
+          "description": "Returns an array containing all values in the dictionary.",
+          "type": "method"
+        },
+        "enumerateKeysAndObjectsUsingBlock:": {
+          "signature": "- (void)enumerateKeysAndObjectsUsingBlock:(void (^)(KeyType key, ObjectType obj, BOOL *stop))block",
+          "description": "Iterates over all key-value pairs, executing the block for each entry.",
+          "type": "method"
+        }
+      }
+    },
+    "NSNumber": {
+      "signature": "@interface NSNumber : NSValue",
+      "description": "An immutable object wrapper for C numeric types including int, float, double, and BOOL. Created using @() literal syntax or factory methods like numberWithInt: for boxing primitives.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "integerValue": {
+          "signature": "@property (readonly) NSInteger integerValue",
+          "description": "Returns the value as an NSInteger (platform-native signed integer).",
+          "type": "method"
+        },
+        "floatValue": {
+          "signature": "@property (readonly) float floatValue",
+          "description": "Returns the value as a float.",
+          "type": "method"
+        },
+        "doubleValue": {
+          "signature": "@property (readonly) double doubleValue",
+          "description": "Returns the value as a double.",
+          "type": "method"
+        },
+        "boolValue": {
+          "signature": "@property (readonly) BOOL boolValue",
+          "description": "Returns the value as a BOOL (YES or NO).",
+          "type": "method"
+        }
+      }
+    },
+    "NSMutableArray": {
+      "signature": "@interface NSMutableArray<ObjectType> : NSArray",
+      "description": "A mutable ordered collection that extends NSArray with methods for adding, removing, and replacing elements. Created using [NSMutableArray array] or [[NSMutableArray alloc] init] factory patterns.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "addObject:": {
+          "signature": "- (void)addObject:(ObjectType)anObject",
+          "description": "Appends an object to the end of the mutable array.",
+          "type": "method"
+        },
+        "removeObjectAtIndex:": {
+          "signature": "- (void)removeObjectAtIndex:(NSUInteger)index",
+          "description": "Removes the object at the specified index from the array.",
+          "type": "method"
+        },
+        "insertObject:atIndex:": {
+          "signature": "- (void)insertObject:(ObjectType)anObject atIndex:(NSUInteger)index",
+          "description": "Inserts an object at the specified index, shifting subsequent elements.",
+          "type": "method"
+        },
+        "removeAllObjects": {
+          "signature": "- (void)removeAllObjects",
+          "description": "Removes all objects from the mutable array, leaving it empty.",
+          "type": "method"
+        },
+        "sortUsingComparator:": {
+          "signature": "- (void)sortUsingComparator:(NSComparator)cmptr",
+          "description": "Sorts the array in place using the given comparison block.",
+          "type": "method"
+        }
+      }
+    },
+    "NSMutableDictionary": {
+      "signature": "@interface NSMutableDictionary<KeyType, ObjectType> : NSDictionary",
+      "description": "A mutable collection of key-value pairs extending NSDictionary with methods for adding, updating, and removing entries. Commonly used for building dynamic configuration and state containers.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "setObject:forKey:": {
+          "signature": "- (void)setObject:(ObjectType)anObject forKey:(KeyType<NSCopying>)aKey",
+          "description": "Adds or replaces the value for the given key in the dictionary.",
+          "type": "method"
+        },
+        "removeObjectForKey:": {
+          "signature": "- (void)removeObjectForKey:(KeyType)aKey",
+          "description": "Removes the key-value pair for the specified key from the dictionary.",
+          "type": "method"
+        },
+        "removeAllObjects": {
+          "signature": "- (void)removeAllObjects",
+          "description": "Removes all key-value pairs from the mutable dictionary.",
+          "type": "method"
+        }
+      }
+    },
+    "NSLog": {
+      "signature": "void NSLog(NSString *format, ...)",
+      "description": "Logs a formatted message to the Apple System Log facility and standard error, prepending a timestamp and process information. Accepts printf-style format specifiers and %@ for objects.",
+      "type": "function",
+      "module": "Foundation"
+    },
+    "dispatch_async": {
+      "signature": "void dispatch_async(dispatch_queue_t queue, dispatch_block_t block)",
+      "description": "Submits a block for asynchronous execution on the specified Grand Central Dispatch queue and returns immediately. Essential for offloading work to background threads and updating UI on the main queue.",
+      "type": "function",
+      "module": "Dispatch"
+    },
+    "dispatch_queue_create": {
+      "signature": "dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)",
+      "description": "Creates a new dispatch queue with the specified label and attributes. Pass DISPATCH_QUEUE_SERIAL for serial execution or DISPATCH_QUEUE_CONCURRENT for concurrent task processing.",
+      "type": "function",
+      "module": "Dispatch"
+    },
+    "@selector": {
+      "signature": "@selector(methodName:)",
+      "description": "Compiler directive that returns a SEL type representing the specified method selector, used for target-action patterns, performSelector calls, and dynamic method invocation in Objective-C runtime.",
+      "type": "function",
+      "module": "Runtime"
+    }
+  }
+}