@fc-components/monaco-editor 0.2.1 → 0.3.2

package/dist/sql/format.d.ts

@@ -0,0 +1 @@
+export declare function formatSql(sql: string): string;

package/dist/sql/index.d.ts

@@ -16,6 +16,13 @@ interface SqlEditorProps {
     onBlur?: (value: string) => void;
     onFocus?: (value: string) => void;
     editorDidMount?: (editor: monacoTypes.editor.IStandaloneCodeEditor) => void;
+    /** Whether to show the format button. Default: false */
+    enableFormat?: boolean;
+    /** Custom format button renderer */
+    renderFormatButton?: (handleFormat: () => void) => React.ReactNode;
 }
-export default function SqlEditor(props: SqlEditorProps): React.JSX.Element;
-export {};
+export interface SqlEditorHandle {
+    format: () => void;
+}
+declare const SqlEditor: React.ForwardRefExoticComponent<SqlEditorProps & React.RefAttributes<SqlEditorHandle>>;
+export default SqlEditor;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.1",
+  "version": "0.3.2",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/monaco-editor.esm.js",
@@ -29,7 +29,10 @@
     "react": ">=16"
   },
   "devDependencies": {
+    "@babel/preset-react": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
     "@size-limit/preset-small-lib": "^11.2.0",
+    "@types/jest": "^30.0.0",
     "@types/lodash": "4.x",
     "@types/pluralize": "^0.0.33",
     "@types/react": "^17.0.0",
@@ -39,6 +42,7 @@
     "react": "^17.0.0",
     "react-dom": "^17.0.0",
     "size-limit": "^11.2.0",
+    "ts-jest": "^29.2.6",
     "tsdx": "^0.14.1",
     "tslib": "^2.8.1",
     "typescript": "^5.8.3"
@@ -54,6 +58,7 @@
     "monaco-promql": "^1.7.4",
     "pluralize": "^8.0.0",
     "react-monaco-editor": "^0.58.0",
+    "sql-formatter": "^15.8.0",
     "uuidv4": "^6.2.13"
   }
 }

package/src/expr/__tests__/__mocks__/monaco-editor.ts

@@ -0,0 +1,34 @@
+export const MarkerSeverity = {
+  Warning: 4,
+  Error: 8,
+  Info: 2,
+  Hint: 1,
+};
+
+export const editor = {
+  setModelMarkers: () => {},
+};
+
+export const languages = {
+  CompletionItemKind: {
+    Keyword: 14,
+    Function: 9,
+  },
+  CompletionItemInsertTextRule: {
+    InsertAsSnippet: 1,
+  },
+};
+
+export const KeyMod = {
+  Shift: 1,
+  CtrlCmd: 2,
+};
+
+export const KeyCode = {
+  Enter: 3,
+  KeyF: 4,
+};
+
+export const Selection = function () {};
+
+export const Range = function () {};

package/src/expr/__tests__/expr.test.tsx

@@ -0,0 +1,339 @@
+import { language, languageConfiguration } from '../expr';
+import { validateExpr } from '../validation';
+import { getExprCompletionProvider } from '../completion/getCompletionProvider';
+
+describe('expr language definition', () => {
+  it('should have correct language id prefix', () => {
+    expect(language.tokenPostfix).toBe('.expr');
+  });
+
+  it('should define keywords', () => {
+    expect(language.keywords).toContain('let');
+    expect(language.keywords).toContain('true');
+    expect(language.keywords).toContain('false');
+    expect(language.keywords).toContain('nil');
+    expect(language.keywords).toContain('in');
+    expect(language.keywords).toContain('not');
+    expect(language.keywords).toContain('and');
+    expect(language.keywords).toContain('or');
+    expect(language.keywords).toContain('if');
+    expect(language.keywords).toContain('else');
+  });
+
+  it('should define builtin functions', () => {
+    expect(language.builtinFunctions).toContain('len');
+    expect(language.builtinFunctions).toContain('now');
+    expect(language.builtinFunctions).toContain('filter');
+    expect(language.builtinFunctions).toContain('map');
+    expect(language.builtinFunctions).toContain('all');
+    expect(language.builtinFunctions).toContain('type');
+    expect(language.builtinFunctions).toContain('bitand');
+  });
+
+  it('should define operators', () => {
+    expect(language.operators).toContain('+');
+    expect(language.operators).toContain('-');
+    expect(language.operators).toContain('*');
+    expect(language.operators).toContain('**');
+    expect(language.operators).toContain('..');
+    expect(language.operators).toContain('|');
+    expect(language.operators).toContain('?.');
+    expect(language.operators).toContain('??');
+    expect(language.operators).toContain('matches');
+    expect(language.operators).toContain('in');
+  });
+
+  it('should have comment configuration', () => {
+    expect(languageConfiguration.comments.lineComment).toBe('//');
+    expect(languageConfiguration.comments.blockComment).toEqual(['/*', '*/']);
+  });
+
+  it('should have bracket configuration', () => {
+    expect(languageConfiguration.brackets).toContainEqual(['{', '}']);
+    expect(languageConfiguration.brackets).toContainEqual(['[', ']']);
+    expect(languageConfiguration.brackets).toContainEqual(['(', ')']);
+  });
+
+  it('should have auto closing pairs', () => {
+    expect(languageConfiguration.autoClosingPairs).toContainEqual({ open: '"', close: '"' });
+    expect(languageConfiguration.autoClosingPairs).toContainEqual({ open: "'", close: "'" });
+    expect(languageConfiguration.autoClosingPairs).toContainEqual({ open: '`', close: '`' });
+    expect(languageConfiguration.autoClosingPairs).toContainEqual({ open: '(', close: ')' });
+  });
+
+  it('should have tokenizer with root section', () => {
+    expect(language.tokenizer).toHaveProperty('root');
+    expect(Array.isArray(language.tokenizer.root)).toBe(true);
+  });
+
+  it('should have all required tokenizer states', () => {
+    const states = Object.keys(language.tokenizer);
+    expect(states).toContain('root');
+    expect(states).toContain('whitespace');
+    expect(states).toContain('comments');
+    expect(states).toContain('comment');
+    expect(states).toContain('numbers');
+    expect(states).toContain('strings');
+    expect(states).toContain('string_double');
+    expect(states).toContain('string_single');
+    expect(states).toContain('string_backtick');
+    expect(states).toContain('bytes');
+    expect(states).toContain('bytes_double');
+    expect(states).toContain('bytes_single');
+  });
+});
+
+describe('expr validation', () => {
+  it('should return empty markers for empty string', () => {
+    const markers = validateExpr('');
+    expect(markers).toHaveLength(0);
+  });
+
+  it('should return empty markers for valid expression', () => {
+    const markers = validateExpr('let x = 42; x * 2');
+    expect(markers).toHaveLength(0);
+  });
+
+  it('should detect unclosed single quote', () => {
+    const markers = validateExpr("let x = 'hello");
+    const quoteMarkers = markers.filter((m) => (m.message || '').includes('quote'));
+    expect(quoteMarkers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unclosed double quote', () => {
+    const markers = validateExpr('let x = "hello');
+    const quoteMarkers = markers.filter((m) => (m.message || '').includes('quote'));
+    expect(quoteMarkers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unclosed backtick', () => {
+    const markers = validateExpr('let x = `hello');
+    const quoteMarkers = markers.filter((m) => (m.message || '').includes('quote') || (m.message || '').includes('backtick'));
+    expect(quoteMarkers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unmatched opening parenthesis', () => {
+    const markers = validateExpr('let x = (1 + 2');
+    const parenMarkers = markers.filter((m) => (m.message || '').includes('parenthesis') || (m.message || '').includes('end of expression') || (m.message || '').includes('")"'));
+    expect(parenMarkers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect mismatch', () => {
+    const markers = validateExpr('let x = 1 + 2)');
+    expect(markers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unmatched opening bracket', () => {
+    const markers = validateExpr('let x = [1, 2');
+    const bracketMarkers = markers.filter((m) => (m.message || '').includes('bracket') || (m.message || '').includes('end of expression') || (m.message || '').includes('"]"'));
+    expect(bracketMarkers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unmatched closing bracket', () => {
+    const markers = validateExpr('let x = 1, 2]');
+    expect(markers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unmatched opening curly brace', () => {
+    const markers = validateExpr('let x = {a: 1');
+    expect(markers.length).toBeGreaterThan(0);
+  });
+
+  it('should detect unmatched closing curly brace', () => {
+    const markers = validateExpr('let x = a: 1}');
+    expect(markers.length).toBeGreaterThan(0);
+  });
+
+  it('should not flag valid closed quotes', () => {
+    const markers = validateExpr('let name = "hello"');
+    const quoteMarkers = markers.filter((m) => (m.message || '').includes('quote'));
+    expect(quoteMarkers).toHaveLength(0);
+  });
+
+  it('should not flag valid closed parentheses', () => {
+    const markers = validateExpr('let x = (1 + 2) * 3');
+    expect(markers).toHaveLength(0);
+  });
+
+  it('should handle block comments', () => {
+    const markers = validateExpr('let x = 1 /* this is a comment */ + 2');
+    expect(markers).toHaveLength(0);
+  });
+
+  it('should handle multi-line block comments', () => {
+    const markers = validateExpr('/* start\nmiddle\nend */ let x = 1');
+    expect(markers).toHaveLength(0);
+  });
+
+  it('should handle balanced quotes', () => {
+    const markers = validateExpr(`let name = "hello" + 'world'`);
+    const quoteMarkers = markers.filter((m) => (m.message || '').includes('quote'));
+    expect(quoteMarkers).toHaveLength(0);
+  });
+});
+
+describe('expr parser syntax validation', () => {
+  it('should accept valid expressions', () => {
+    const validExprs = [
+      '42',
+      '"hello"',
+      'true',
+      'nil',
+      'a + b',
+      'a * b + c',
+      'a > 5',
+      'a || b && c',
+      'user.Name',
+      'user?.Name',
+      'arr[0]',
+      'arr[1:3]',
+      'foo(1, 2)',
+      'len(arr)',
+      'filter(arr, {# > 2})',
+      '[1, 2, 3]',
+      '{a: 1, b: 2}',
+      'let x = 42; x * 2',
+      'a ? b : c',
+      'a ?: c',
+      'a ?? b',
+      'a | upper()',
+      'a matches "foo"',
+      'a contains "bar"',
+      'now()',
+      'a + b; c + d',
+    ];
+
+    for (const expr of validExprs) {
+      const markers = validateExpr(expr);
+      const syntaxErrors = markers.filter((m) => m.severity === 8);
+      expect(syntaxErrors.map((e) => `${expr}: ${e.message}`)).toEqual([]);
+    }
+  });
+
+  it('should report unexpected token', () => {
+    const markers = validateExpr('42 @ 10');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].message).toContain('unexpected token');
+  });
+
+  it('should report unexpected end of expression', () => {
+    const markers = validateExpr('foo(');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should report expected identifier after let', () => {
+    const markers = validateExpr('let 42 = 10');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].message).toContain('variable name');
+  });
+
+  it('should report expected = after variable name', () => {
+    const markers = validateExpr('let x 10');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].message).toContain('expected "="');
+  });
+
+  it('should report missing map value after colon', () => {
+    const markers = validateExpr('{a:}');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should report unexpected token in array', () => {
+    const markers = validateExpr('[1 2]');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should report missing closing parenthesis', () => {
+    const markers = validateExpr('(1 + 2');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should report missing property after dot', () => {
+    const markers = validateExpr('user.');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should report missing identifier after pipe', () => {
+    const markers = validateExpr('a |');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should handle complex valid expressions', () => {
+    const markers = validateExpr('filter(users, {.Age > 18 && .Name startsWith "J"})');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors).toHaveLength(0);
+  });
+
+  it('should validate expression with pipe and builtin', () => {
+    const markers = validateExpr('user.Name | upper() | split(" ")');
+    const errors = markers.filter((m) => m.severity === 8);
+    expect(errors).toHaveLength(0);
+  });
+});
+
+describe('expr completion provider', () => {
+  it('should return a completion provider', () => {
+    const provider = getExprCompletionProvider();
+    expect(provider).toBeDefined();
+    expect(typeof provider.provideCompletionItems).toBe('function');
+  });
+
+  it('should provide keywords in suggestions', async () => {
+    const provider = getExprCompletionProvider();
+    const mockModel: any = {
+      getWordUntilPosition: () => ({ startColumn: 1, endColumn: 1, word: '' }),
+      getValue: () => '',
+      getLineContent: () => '',
+    };
+    const mockPosition: any = { lineNumber: 1, column: 1 };
+    const emptyContext: any = {};
+    const emptyToken: any = {};
+
+    const result = await provider.provideCompletionItems(mockModel, mockPosition, emptyContext, emptyToken);
+    const suggestions = (result && result.suggestions) || [];
+
+    const keywordLabels = suggestions.filter((s: any) => s.kind === 14).map((s: any) => s.label);
+
+    expect(keywordLabels).toContain('let');
+    expect(keywordLabels).toContain('true');
+    expect(keywordLabels).toContain('false');
+    expect(keywordLabels).toContain('nil');
+  });
+
+  it('should provide functions in suggestions', async () => {
+    const provider = getExprCompletionProvider();
+    const mockModel: any = {
+      getWordUntilPosition: () => ({ startColumn: 1, endColumn: 1, word: '' }),
+      getValue: () => '',
+      getLineContent: () => '',
+    };
+    const mockPosition: any = { lineNumber: 1, column: 1 };
+    const emptyContext: any = {};
+    const emptyToken: any = {};
+
+    const result = await provider.provideCompletionItems(mockModel, mockPosition, emptyContext, emptyToken);
+    const suggestions = (result && result.suggestions) || [];
+
+    const functionLabels = suggestions
+      .filter(function (s) {
+        return s.kind === 9;
+      })
+      .map(function (s) {
+        return s.label;
+      });
+
+    expect(functionLabels).toContain('len');
+    expect(functionLabels).toContain('filter');
+    expect(functionLabels).toContain('map');
+    expect(functionLabels).toContain('now');
+  });
+});

package/src/expr/completion/getCompletionProvider.ts

@@ -0,0 +1,133 @@
+import * as monaco from 'monaco-editor';
+
+const EXPR_KEYWORDS = ['let', 'true', 'false', 'nil', 'in', 'not', 'and', 'or', 'if', 'else'];
+
+const EXPR_FUNCTIONS: { name: string; signature: string; description: string; category: string }[] = [
+  // String functions
+  { name: 'trim', signature: 'trim(str[, chars])', description: 'Removes white spaces from both ends of a string', category: 'string' },
+  { name: 'trimPrefix', signature: 'trimPrefix(str, prefix)', description: 'Removes the specified prefix from the string', category: 'string' },
+  { name: 'trimSuffix', signature: 'trimSuffix(str, suffix)', description: 'Removes the specified suffix from the string', category: 'string' },
+  { name: 'upper', signature: 'upper(str)', description: 'Converts all characters to uppercase', category: 'string' },
+  { name: 'lower', signature: 'lower(str)', description: 'Converts all characters to lowercase', category: 'string' },
+  { name: 'split', signature: 'split(str, delimiter[, n])', description: 'Splits a string at each instance of the delimiter', category: 'string' },
+  { name: 'splitAfter', signature: 'splitAfter(str, delimiter[, n])', description: 'Splits a string after each instance of the delimiter', category: 'string' },
+  { name: 'replace', signature: 'replace(str, old, new)', description: 'Replaces all occurrences of old with new', category: 'string' },
+  { name: 'repeat', signature: 'repeat(str, n)', description: 'Repeats a string n times', category: 'string' },
+  { name: 'indexOf', signature: 'indexOf(str, substring)', description: 'Returns the index of the first occurrence of substring', category: 'string' },
+  { name: 'lastIndexOf', signature: 'lastIndexOf(str, substring)', description: 'Returns the index of the last occurrence of substring', category: 'string' },
+  { name: 'hasPrefix', signature: 'hasPrefix(str, prefix)', description: 'Returns true if string starts with the given prefix', category: 'string' },
+  { name: 'hasSuffix', signature: 'hasSuffix(str, suffix)', description: 'Returns true if string ends with the given suffix', category: 'string' },
+  { name: 'contains', signature: 'contains(str, substr)', description: 'Returns true if string contains the given substring', category: 'string' },
+  { name: 'startsWith', signature: 'startsWith(str, prefix)', description: 'Returns true if string starts with the given prefix', category: 'string' },
+  { name: 'endsWith', signature: 'endsWith(str, suffix)', description: 'Returns true if string ends with the given suffix', category: 'string' },
+
+  // Date functions
+  { name: 'now', signature: 'now()', description: 'Returns the current date as a time.Time value', category: 'date' },
+  { name: 'duration', signature: 'duration(str)', description: 'Returns time.Duration value of the given string', category: 'date' },
+  { name: 'date', signature: 'date(str[, format[, timezone]])', description: 'Converts the given string into a date representation', category: 'date' },
+  { name: 'timezone', signature: 'timezone(str)', description: 'Returns the timezone of the given string', category: 'date' },
+
+  // Number functions
+  { name: 'max', signature: 'max(n1, n2)', description: 'Returns the maximum of two numbers', category: 'number' },
+  { name: 'min', signature: 'min(n1, n2)', description: 'Returns the minimum of two numbers', category: 'number' },
+  { name: 'abs', signature: 'abs(n)', description: 'Returns the absolute value of a number', category: 'number' },
+  { name: 'ceil', signature: 'ceil(n)', description: 'Returns the least integer value greater than or equal to x', category: 'number' },
+  { name: 'floor', signature: 'floor(n)', description: 'Returns the greatest integer value less than or equal to x', category: 'number' },
+  { name: 'round', signature: 'round(n)', description: 'Returns the nearest integer, rounding half away from zero', category: 'number' },
+
+  // Array functions
+  { name: 'all', signature: 'all(array, predicate)', description: 'Returns true if all elements satisfy the predicate', category: 'array' },
+  { name: 'any', signature: 'any(array, predicate)', description: 'Returns true if any elements satisfy the predicate', category: 'array' },
+  { name: 'one', signature: 'one(array, predicate)', description: 'Returns true if exactly one element satisfies the predicate', category: 'array' },
+  { name: 'none', signature: 'none(array, predicate)', description: 'Returns true if no elements satisfy the predicate', category: 'array' },
+  { name: 'map', signature: 'map(array, predicate)', description: 'Returns new array by applying the predicate to each element', category: 'array' },
+  { name: 'filter', signature: 'filter(array, predicate)', description: 'Returns new array by filtering elements by predicate', category: 'array' },
+  { name: 'find', signature: 'find(array, predicate)', description: 'Finds the first element satisfying the predicate', category: 'array' },
+  { name: 'findIndex', signature: 'findIndex(array, predicate)', description: 'Finds the index of the first element satisfying the predicate', category: 'array' },
+  { name: 'findLast', signature: 'findLast(array, predicate)', description: 'Finds the last element satisfying the predicate', category: 'array' },
+  { name: 'findLastIndex', signature: 'findLastIndex(array, predicate)', description: 'Finds the index of the last element satisfying the predicate', category: 'array' },
+  { name: 'groupBy', signature: 'groupBy(array, predicate)', description: 'Groups elements by the result of the predicate', category: 'array' },
+  { name: 'count', signature: 'count(array[, predicate])', description: 'Returns the number of elements satisfying the predicate', category: 'array' },
+  { name: 'concat', signature: 'concat(array1, array2[, ...])', description: 'Concatenates two or more arrays', category: 'array' },
+  { name: 'flatten', signature: 'flatten(array)', description: 'Flattens an array into one-dimensional array', category: 'array' },
+  { name: 'uniq', signature: 'uniq(array)', description: 'Removes duplicates from an array', category: 'array' },
+  { name: 'join', signature: 'join(array[, delimiter])', description: 'Joins an array of strings into a single string', category: 'array' },
+  { name: 'reduce', signature: 'reduce(array, predicate[, initial])', description: 'Reduces an array to a single value', category: 'array' },
+  { name: 'sum', signature: 'sum(array[, predicate])', description: 'Returns the sum of all numbers in an array', category: 'array' },
+  { name: 'mean', signature: 'mean(array)', description: 'Returns the average of all numbers in an array', category: 'array' },
+  { name: 'median', signature: 'median(array)', description: 'Returns the median of all numbers in an array', category: 'array' },
+  { name: 'first', signature: 'first(array)', description: 'Returns the first element from an array', category: 'array' },
+  { name: 'last', signature: 'last(array)', description: 'Returns the last element from an array', category: 'array' },
+  { name: 'take', signature: 'take(array, n)', description: 'Returns the first n elements from an array', category: 'array' },
+  { name: 'reverse', signature: 'reverse(array)', description: 'Returns a new reversed copy of the array', category: 'array' },
+  { name: 'sort', signature: 'sort(array[, order])', description: 'Sorts an array in ascending or descending order', category: 'array' },
+  { name: 'sortBy', signature: 'sortBy(array[, predicate, order])', description: 'Sorts an array by the result of the predicate', category: 'array' },
+
+  // Map functions
+  { name: 'keys', signature: 'keys(map)', description: 'Returns an array containing the keys of the map', category: 'map' },
+  { name: 'values', signature: 'values(map)', description: 'Returns an array containing the values of the map', category: 'map' },
+
+  // Type conversion functions
+  { name: 'type', signature: 'type(v)', description: 'Returns the type of the given value', category: 'conversion' },
+  { name: 'int', signature: 'int(v)', description: 'Returns the integer value of a number or string', category: 'conversion' },
+  { name: 'float', signature: 'float(v)', description: 'Returns the float value of a number or string', category: 'conversion' },
+  { name: 'string', signature: 'string(v)', description: 'Converts a value to its string representation', category: 'conversion' },
+  { name: 'toJSON', signature: 'toJSON(v)', description: 'Converts a value to JSON string representation', category: 'conversion' },
+  { name: 'fromJSON', signature: 'fromJSON(v)', description: 'Parses a JSON string to a value', category: 'conversion' },
+  { name: 'toBase64', signature: 'toBase64(v)', description: 'Encodes a string into Base64 format', category: 'conversion' },
+  { name: 'fromBase64', signature: 'fromBase64(v)', description: 'Decodes a Base64 encoded string', category: 'conversion' },
+  { name: 'toPairs', signature: 'toPairs(map)', description: 'Converts a map to an array of key-value pairs', category: 'conversion' },
+  { name: 'fromPairs', signature: 'fromPairs(array)', description: 'Converts an array of key-value pairs to a map', category: 'conversion' },
+
+  // Miscellaneous functions
+  { name: 'len', signature: 'len(v)', description: 'Returns the length of an array, map, or string', category: 'misc' },
+  { name: 'get', signature: 'get(v, index)', description: 'Retrieves element at the specified index from an array or map', category: 'misc' },
+
+  // Bitwise functions
+  { name: 'bitand', signature: 'bitand(int, int)', description: 'Returns the bitwise AND of two integers', category: 'bitwise' },
+  { name: 'bitor', signature: 'bitor(int, int)', description: 'Returns the bitwise OR of two integers', category: 'bitwise' },
+  { name: 'bitxor', signature: 'bitxor(int, int)', description: 'Returns the bitwise XOR of two integers', category: 'bitwise' },
+  { name: 'bitnand', signature: 'bitnand(int, int)', description: 'Returns the bitwise AND NOT of two integers', category: 'bitwise' },
+  { name: 'bitnot', signature: 'bitnot(int)', description: 'Returns the bitwise NOT of an integer', category: 'bitwise' },
+  { name: 'bitshl', signature: 'bitshl(int, int)', description: 'Returns the Left Shift of an integer', category: 'bitwise' },
+  { name: 'bitshr', signature: 'bitshr(int, int)', description: 'Returns the Right Shift of an integer', category: 'bitwise' },
+  { name: 'bitushr', signature: 'bitushr(int, int)', description: 'Returns the unsigned Right Shift of an integer', category: 'bitwise' },
+];
+
+export const getExprCompletionProvider = () => {
+  return {
+    provideCompletionItems(
+      model: monaco.editor.ITextModel,
+      position: monaco.Position,
+      _context: monaco.languages.CompletionContext,
+      _token: monaco.CancellationToken,
+    ): monaco.languages.ProviderResult<monaco.languages.CompletionList> {
+      const word = model.getWordUntilPosition(position);
+      const range = new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+
+      const suggestions: monaco.languages.CompletionItem[] = [
+        ...EXPR_KEYWORDS.map((keyword) => ({
+          label: keyword,
+          kind: monaco.languages.CompletionItemKind.Keyword,
+          insertText: keyword,
+          range: range,
+          sortText: '1' + keyword,
+        })),
+        ...EXPR_FUNCTIONS.map((func) => ({
+          label: func.name,
+          kind: monaco.languages.CompletionItemKind.Function,
+          insertText: func.name,
+          detail: func.signature,
+          documentation: func.description + ` (${func.category})`,
+          range: range,
+          sortText: '2' + func.name,
+          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        })),
+      ];
+
+      return {
+        suggestions: suggestions,
+      };
+    },
+  };
+};