@bpmn-io/feel-editor 1.4.0 → 1.6.0

package/dist/index.es.js

@@ -1,18 +1,116 @@
-import { snippetCompletion, autocompletion as autocompletion$1, completeFromList, closeBrackets } from '@codemirror/autocomplete';
+import { snippetCompletion, autocompletion, closeBrackets } from '@codemirror/autocomplete';
 import { defaultKeymap } from '@codemirror/commands';
-import { syntaxTree, LanguageSupport, syntaxHighlighting, HighlightStyle, bracketMatching, indentOnInput } from '@codemirror/language';
+import { syntaxHighlighting, HighlightStyle, syntaxTree, bracketMatching, indentOnInput } from '@codemirror/language';
 import { linter as linter$1, setDiagnosticsEffect } from '@codemirror/lint';
 import { Facet, Compartment, EditorState } from '@codemirror/state';
-import { EditorView, tooltips, keymap } from '@codemirror/view';
-import { snippets, keywordCompletions, feelLanguage } from 'lang-feel';
-import { domify } from 'min-dom';
+import { EditorView, tooltips, keymap, placeholder } from '@codemirror/view';
 import { cmFeelLinter } from '@bpmn-io/feel-lint';
-import { tags as tags$1 } from '@lezer/highlight';
+import { tags } from '@lezer/highlight';
+import { snippetCompletion as snippetCompletion$1, snippets, keywordCompletions, feel } from 'lang-feel';
+import { domify } from 'min-dom';
+
+var linter = [ linter$1(cmFeelLinter()) ];
+
+const baseTheme = EditorView.theme({
+  '& .cm-content': {
+    padding: '0px',
+  },
+  '& .cm-line': {
+    padding: '0px',
+  },
+  '&.cm-editor.cm-focused': {
+    outline: 'none',
+  },
+  '& .cm-completionInfo': {
+    whiteSpace: 'pre-wrap',
+    overflow: 'hidden',
+    textOverflow: 'ellipsis'
+  },
+
+  // Don't wrap whitespace for custom HTML
+  '& .cm-completionInfo > *': {
+    whiteSpace: 'normal'
+  },
+  '& .cm-completionInfo ul': {
+    margin: 0,
+    paddingLeft: '15px'
+  },
+  '& .cm-completionInfo pre': {
+    marginBottom: 0,
+    whiteSpace: 'pre-wrap'
+  },
+  '& .cm-completionInfo p': {
+    marginTop: 0,
+  },
+  '& .cm-completionInfo p:not(:last-of-type)': {
+    marginBottom: 0,
+  }
+});
+
+const highlightTheme = EditorView.baseTheme({
+  '& .variableName': {
+    color: '#10f'
+  },
+  '& .number': {
+    color: '#164'
+  },
+  '& .string': {
+    color: '#a11'
+  },
+  '& .bool': {
+    color: '#219'
+  },
+  '& .function': {
+    color: '#aa3731',
+    fontWeight: 'bold'
+  },
+  '& .control': {
+    color: '#708'
+  }
+});
+
+const syntaxClasses = syntaxHighlighting(
+  HighlightStyle.define([
+    { tag: tags.variableName, class: 'variableName' },
+    { tag: tags.name, class: 'variableName' },
+    { tag: tags.number, class: 'number' },
+    { tag: tags.string, class: 'string' },
+    { tag: tags.bool, class: 'bool' },
+    { tag: tags.function(tags.variableName), class: 'function' },
+    { tag: tags.function(tags.special(tags.variableName)), class: 'function' },
+    { tag: tags.controlKeyword, class: 'control' },
+    { tag: tags.operatorKeyword, class: 'control' }
+  ])
+);
+
+var theme = [ baseTheme, highlightTheme, syntaxClasses ];
 
 // helpers ///////////////////////////////
 
-function isNodeEmpty(node) {
-  return node.from === node.to;
+function _isEmpty(node) {
+  return node && node.from === node.to;
+}
+
+/**
+ * @param {any} node
+ * @param {number} pos
+ *
+ * @return {boolean}
+ */
+function isEmpty(node, pos) {
+
+  // For the special case of empty nodes, we need to check the current node
+  // as well. The previous node could be part of another token, e.g.
+  // when typing functions "abs(".
+  const nextNode = node.nextSibling;
+
+  return _isEmpty(node) || (
+    nextNode && nextNode.from === pos && _isEmpty(nextNode)
+  );
+}
+
+function isVariableName(node) {
+  return node && node.parent && node.parent.name === 'VariableName';
 }
 
 function isPathExpression(node) {
@@ -27,7 +125,382 @@ function isPathExpression(node) {
   return isPathExpression(node.parent);
 }
 
-var tags = [
+/**
+ * @typedef { import('../core').Variable } Variable
+ * @typedef { import('@codemirror/autocomplete').CompletionSource } CompletionSource
+ */
+
+/**
+ * @param { {
+ *   variables?: Variable[],
+ * } } options
+ *
+ * @return { CompletionSource }
+ */
+function pathExpressionCompletion({ variables }) {
+
+  return (context) => {
+
+    const nodeBefore = syntaxTree(context.state).resolve(context.pos, -1);
+
+    if (!isPathExpression(nodeBefore)) {
+      return;
+    }
+
+    const expression = findPathExpression(nodeBefore);
+
+    // if the cursor is directly after the `.`, variable starts at the cursor position
+    const from = nodeBefore === expression ? context.pos : nodeBefore.from;
+
+    const path = getPath(expression, context);
+
+    let options = variables;
+    for (var i = 0; i < path.length - 1; i++) {
+      var childVar = options.find(val => val.name === path[i].name);
+
+      if (!childVar) {
+        return null;
+      }
+
+      // only suggest if variable type matches
+      if (
+        childVar.isList !== 'optional' &&
+        !!childVar.isList !== path[i].isList
+      ) {
+        return;
+      }
+
+      options = childVar.entries;
+    }
+
+    if (!options) return;
+
+    options = options.map(v => ({
+      label: v.name,
+      type: 'variable',
+      info: v.info,
+      detail: v.detail
+    }));
+
+    const result = {
+      from: from,
+      options: options
+    };
+
+    return result;
+  };
+}
+
+
+function findPathExpression(node) {
+  while (node) {
+    if (node.name === 'PathExpression') {
+      return node;
+    }
+    node = node.parent;
+  }
+}
+
+// parses the path expression into a list of variable names with type information
+// e.g. foo[0].bar => [ { name: 'foo', isList: true }, { name: 'bar', isList: false } ]
+function getPath(node, context) {
+  let path = [];
+
+  for (let child = node.firstChild; child; child = child.nextSibling) {
+    if (child.name === 'PathExpression') {
+      path.push(...getPath(child, context));
+    } else if (child.name === 'FilterExpression') {
+      path.push(...getFilter(child, context));
+    }
+    else {
+      path.push({
+        name: getNodeContent(child, context),
+        isList: false
+      });
+    }
+  }
+  return path;
+}
+
+function getFilter(node, context) {
+  const list = node.firstChild;
+
+  if (list.name === 'PathExpression') {
+    const path = getPath(list, context);
+    const last = path[path.length - 1];
+    last.isList = true;
+
+    return path;
+  }
+
+  return [ {
+    name: getNodeContent(list, context),
+    isList: true
+  } ];
+}
+
+function getNodeContent(node, context) {
+  return context.state.sliceDoc(node.from, node.to);
+}
+
+/**
+ * @typedef { import('../core').Variable } Variable
+ * @typedef { import('@codemirror/autocomplete').CompletionSource } CompletionSource
+ */
+
+/**
+ * @param { {
+ *   variables?: Variable[],
+ *   builtins?: Variable[]
+ * } } options
+ *
+ * @return { CompletionSource }
+ */
+function variableCompletion({ variables = [], builtins = [] }) {
+
+  const options = getVariableSuggestions(variables, builtins);
+
+  if (!options.length) {
+    return (context) => null;
+  }
+
+  return (context) => {
+
+    const {
+      pos,
+      state
+    } = context;
+
+    // in most cases, use what is typed before the cursor
+    const nodeBefore = syntaxTree(state).resolve(pos, -1);
+
+    if (isEmpty(nodeBefore, pos)) {
+      return context.explicit ? {
+        from: pos,
+        options
+      } : null;
+    }
+
+    // only auto-complete variables
+    if (!isVariableName(nodeBefore) || isPathExpression(nodeBefore)) {
+      return null;
+    }
+
+    return {
+      from: nodeBefore.from,
+      options
+    };
+  };
+}
+
+/**
+ * @param { Variable[] } variables
+ * @param { Variable[] } builtins
+ *
+ * @returns {import('@codemirror/autocomplete').Completion[]}
+ */
+function getVariableSuggestions(variables, builtins) {
+  return [].concat(
+    variables.map(v => createVariableSuggestion(v)),
+    builtins.map(b => createVariableSuggestion(b))
+  );
+}
+
+/**
+ * @param {import('..').Variable} variable
+ * @param {number} boost
+
+ * @returns {import('@codemirror/autocomplete').Completion}
+ */
+function createVariableSuggestion(variable, boost) {
+  if (variable.type === 'function') {
+    return createFunctionVariable(variable, boost);
+  }
+
+  return {
+    label: variable.name,
+    type: 'variable',
+    info: variable.info,
+    detail: variable.detail,
+    boost
+  };
+}
+
+/**
+ * @param {import('..').Variable} variable
+ * @param {number} boost
+ *
+ * @returns {import('@codemirror/autocomplete').Completion}
+ */
+function createFunctionVariable(variable, boost) {
+  const {
+    name,
+    info,
+    detail,
+    params = []
+  } = variable;
+
+  const paramsWithNames = params.map(({ name, type }, index) => ({
+    name: name || `param ${index + 1}`,
+    type
+  }));
+
+  const template = `${name}(${paramsWithNames.map(p => '${' + p.name + '}').join(', ')})`;
+
+  const paramsSignature = paramsWithNames.map(({ name, type }) => (
+    type ? `${name}: ${type}` : name
+  )).join(', ');
+  const label = `${name}(${paramsSignature})`;
+
+  return snippetCompletion(template, {
+    label,
+    type: 'function',
+    info,
+    detail,
+    boost
+  });
+}
+
+/**
+ * @typedef { import('../core').Variable } Variable
+ * @typedef { import('@codemirror/autocomplete').CompletionSource } CompletionSource
+ */
+
+/**
+ * @param { {
+ *   variables?: Variable[],
+ *   builtins?: Variable[]
+ * } } options
+ *
+ * @return { CompletionSource[] }
+ */
+function completions({ variables = [], builtins = [] }) {
+
+  return [
+    pathExpressionCompletion({ variables }),
+    variableCompletion({ variables, builtins }),
+    snippetCompletion$1(snippets.map(snippet => ({ ...snippet, boost: -1 }))),
+    ...keywordCompletions
+  ];
+}
+
+/**
+ * @typedef { 'expression' | 'unaryTests' } Dialect
+ */
+
+/**
+ * @param { {
+ *   dialect?: Dialect,
+ *   context?: Record<string, any>,
+ *   completions?: import('@codemirror/autocomplete').CompletionSource[]
+ * } } options
+ *
+ * @return { import('@codemirror/language').LanguageSupport }
+ */
+function language(options) {
+  return feel(options);
+}
+
+/**
+ * @param { import('../core').Variable[] } variables
+ *
+ * @return {Record<string, any>}
+ */
+function createContext(variables, builtins) {
+  return variables.slice().reverse().reduce((context, builtin) => {
+    context[builtin.name] = new Function();
+
+    return context;
+  }, {});
+}
+
+/**
+ * @typedef { 'expression' | 'unaryTests' } Dialect
+ * @typedef { import('..').Variable } Variable
+ */
+
+/**
+ * @type {Facet<Variable[]>}
+ */
+const builtinsFacet = Facet.define();
+
+/**
+ * @type {Facet<Variable[]>}
+ */
+const variablesFacet = Facet.define();
+
+/**
+ * @type {Facet<dialect>}
+ */
+const dialectFacet = Facet.define();
+
+/**
+ * @typedef {object} Variable
+ * @property {string} name name or key of the variable
+ * @property {string} [info] short information about the variable, e.g. type
+ * @property {string} [detail] longer description of the variable content
+ * @property {boolean} [isList] whether the variable is a list
+ * @property {Array<Variable>} [schema] array of child variables if the variable is a context or list
+ * @property {'function'|'variable'} [type] type of the variable
+ * @property {Array<{name: string, type: string}>} [params] function parameters
+ */
+
+/**
+ * @typedef { {
+ *   dialect?: import('../language').Dialect,
+ *   variables?: Variable[],
+ *   builtins?: Variable[]
+ * } } CoreConfig
+ *
+ * @typedef { import('@codemirror/autocomplete').CompletionSource } CompletionSource
+ * @typedef { import('@codemirror/state').Extension } Extension
+ */
+
+/**
+ * @param { CoreConfig & { completions?: CompletionSource[] } } config
+ *
+ * @return { Extension  }
+ */
+function configure({
+  dialect = 'expression',
+  variables = [],
+  builtins = [],
+  completions: completions$1 = completions({ builtins, variables })
+}) {
+
+  const context = createContext([ ...variables, ...builtins ]);
+
+  return [
+    dialectFacet.of(dialect),
+    builtinsFacet.of(builtins),
+    variablesFacet.of(variables),
+    language({
+      dialect,
+      context,
+      completions: completions$1
+    })
+  ];
+}
+
+/**
+ * @param {import('@codemirror/state').EditorState } state
+ *
+ * @return { CoreConfig }
+ */
+function get(state) {
+
+  const builtins = state.facet(builtinsFacet)[0];
+  const variables = state.facet(variablesFacet)[0];
+  const dialect = state.facet(dialectFacet)[0];
+
+  return {
+    builtins,
+    variables,
+    dialect
+  };
+}
+
+var camundaTags = [
 	{
 		name: "not(negand)",
 		description: "<p>Returns the logical negation of the given value.</p>\n<p><strong>Function signature</strong></p>\n<pre><code class=\"language-feel\">not(negand: boolean): boolean\n</code></pre>\n<p><strong>Examples</strong></p>\n<pre><code class=\"language-feel\">not(true)\n// false\n\nnot(null)\n// null\n</code></pre>\n"
@@ -106,7 +579,7 @@ var tags = [
 	},
 	{
 		name: "date and time(from)",
-		description: "<p>Parses the given string into a date and time.</p>\n<p><strong>Function signature</strong></p>\n<pre><code class=\"language-feel\">date and time(from: string): date and time\n</code></pre>\n<p><strong>Examples</strong></p>\n<pre><code class=\"language-feel\">date and time(&quot;2018-04-29T009:30:00&quot;)\n// date and time(&quot;2018-04-29T009:30:00&quot;)\n</code></pre>\n"
+		description: "<p>Parses the given string into a date and time.</p>\n<p><strong>Function signature</strong></p>\n<pre><code class=\"language-feel\">date and time(from: string): date and time\n</code></pre>\n<p><strong>Examples</strong></p>\n<pre><code class=\"language-feel\">date and time(&quot;2018-04-29T09:30:00&quot;)\n// date and time(&quot;2018-04-29T09:30:00&quot;)\n</code></pre>\n"
 	},
 	{
 		name: "date and time(date, time)",
@@ -510,363 +983,59 @@ var tags = [
 	}
 ];
 
-const options = tags.map(tag => {
-  const match = tag.name.match(/^([\w\s]+)\((.*)\)$/);
-  const functionName = match[1];
-  const functionArguments = match[2];
-
-  const placeHolders = functionArguments
-    .split(', ')
-    .map((arg) => `\${${arg}}`)
-    .join(', ');
-
-  return snippetCompletion(
-    `${functionName}(${placeHolders})`,
-    {
-      label: tag.name,
-      type: 'function',
-      info: () => {
-        const html = domify(`<div class="description">${tag.description}<div>`);
-        return html;
-      },
-      boost: -1
-    }
-  );
-});
-
-var builtins = context => {
-
-  let nodeBefore = syntaxTree(context.state).resolve(context.pos, -1);
-
-  // For the special case of empty nodes, we need to check the current node
-  // as well. The previous node could be part of another token, e.g.
-  // when typing functions "abs(".
-  let nextNode = nodeBefore.nextSibling;
-  const isInEmptyNode =
-        isNodeEmpty(nodeBefore) ||
-        nextNode && nextNode.from === context.pos && isNodeEmpty(nextNode);
-
-  if (isInEmptyNode) {
-    return context.explicit ? {
-      from: context.pos,
-      options: options
-    } : null;
-  }
-
-  // Don't auto-complete on path expressions/context keys/...
-  if ((nodeBefore.parent && nodeBefore.parent.name !== 'VariableName') || isPathExpression(nodeBefore)) {
-    return null;
-  }
-
-  return {
-    from: nodeBefore.from,
-    options: options
-  };
-};
-
 /**
- * @type {Facet<import('..').Variable[]>} Variable
+ * @param { import('..').Builtin[] } builtins
+ *
+ * @returns {import('..').Variable[] } variable
  */
-const variablesFacet = Facet.define();
-
-var pathExpression = context => {
-  const variables = context.state.facet(variablesFacet)[0];
-  const nodeBefore = syntaxTree(context.state).resolve(context.pos, -1);
-
-  if (!isPathExpression(nodeBefore)) {
-    return;
-  }
-
-  const expression = findPathExpression(nodeBefore);
-
-  // if the cursor is directly after the `.`, variable starts at the cursor position
-  const from = nodeBefore === expression ? context.pos : nodeBefore.from;
-
-  const path = getPath(expression, context);
-
-  let options = variables;
-  for (var i = 0; i < path.length - 1; i++) {
-    var childVar = options.find(val => val.name === path[i].name);
-
-    if (!childVar) {
-      return null;
-    }
-
-    // only suggest if variable type matches
-    if (
-      childVar.isList !== 'optional' &&
-      !!childVar.isList !== path[i].isList
-    ) {
-      return;
-    }
-
-    options = childVar.entries;
-  }
-
-  if (!options) return;
-
-  options = options.map(v => ({
-    label: v.name,
-    type: 'variable',
-    info: v.info,
-    detail: v.detail
-  }));
-
-  const result = {
-    from: from,
-    options: options
-  };
-
-  return result;
-};
-
-
-function findPathExpression(node) {
-  while (node) {
-    if (node.name === 'PathExpression') {
-      return node;
-    }
-    node = node.parent;
-  }
-}
-
-// parses the path expression into a list of variable names with type information
-// e.g. foo[0].bar => [ { name: 'foo', isList: true }, { name: 'bar', isList: false } ]
-function getPath(node, context) {
-  let path = [];
-
-  for (let child = node.firstChild; child; child = child.nextSibling) {
-    if (child.name === 'PathExpression') {
-      path.push(...getPath(child, context));
-    } else if (child.name === 'FilterExpression') {
-      path.push(...getFilter(child, context));
-    }
-    else {
-      path.push({
-        name: getNodeContent(child, context),
-        isList: false
-      });
-    }
-  }
-  return path;
-}
-
-function getFilter(node, context) {
-  const list = node.firstChild;
-
-  if (list.name === 'PathExpression') {
-    const path = getPath(list, context);
-    const last = path[path.length - 1];
-    last.isList = true;
-
-    return path;
-  }
-
-  return [ {
-    name: getNodeContent(list, context),
-    isList: true
-  } ];
+function parseBuiltins(builtins) {
+  return builtins.map(parseBuiltin);
 }
 
-function getNodeContent(node, context) {
-  return context.state.sliceDoc(node.from, node.to);
-}
-
-/**
- * @type {import('@codemirror/autocomplete').CompletionSource}
- */
-var variables = context => {
-
-  const variables = context.state.facet(variablesFacet)[0];
-
-  const options = variables.map(v => createVariableSuggestion(v));
-
-  // In most cases, use what is typed before the cursor
-  let nodeBefore = syntaxTree(context.state).resolve(context.pos, -1);
-
-  // For the special case of empty nodes, we need to check the current node
-  // as well. The previous node could be part of another token, e.g.
-  // when typing functions "abs(".
-  let nextNode = nodeBefore.nextSibling;
-  const isInEmptyNode =
-        isNodeEmpty(nodeBefore) ||
-        nextNode && nextNode.from === context.pos && isNodeEmpty(nextNode);
-
-  if (isInEmptyNode) {
-    return context.explicit ? {
-      from: context.pos,
-      options: options
-    } : null;
-  }
-
-  const result = {
-    from: nodeBefore.from,
-    options: options
-  };
-
-  // Only auto-complete variables
-  if ((nodeBefore.parent && nodeBefore.parent.name !== 'VariableName') || isPathExpression(nodeBefore)) {
-    return null;
-  }
-
-  return result;
-};
-
 /**
- * @param {import('..').Variable} variable
- * @returns {import('@codemirror/autocomplete').Completion}
+ * @param { import('..').Builtin } builtin
+ *
+ * @returns { import('..').Variable } variable
  */
-function createVariableSuggestion(variable) {
-  if (variable.type === 'function') {
-    return createFunctionVariable(variable);
-  }
-
-  return {
-    label: variable.name,
-    type: 'variable',
-    info: variable.info,
-    detail: variable.detail
-  };
-}
+function parseBuiltin(builtin) {
 
-/**
- * @param {import('..').Variable} variable
- * @returns {import('@codemirror/autocomplete').Completion}
- */
-function createFunctionVariable(variable) {
   const {
     name,
-    info,
-    detail,
-    params = []
-  } = variable;
-
-  const paramsWithNames = params.map(({ name, type }, index) => ({
-    name: name || `param ${index + 1}`,
-    type
-  }));
+    description
+  } = builtin;
 
-  const template = `${name}(${paramsWithNames.map(p => '${' + p.name + '}').join(', ')})`;
+  const match = name.match(/^([\w\s]+)\((.*)\)$/);
+  const functionName = match[1];
+  const functionArguments = match[2];
 
-  const paramsSignature = paramsWithNames.map(({ name, type }) => (
-    type ? `${name}: ${type}` : name
-  )).join(', ');
-  const label = `${name}(${paramsSignature})`;
+  const params = functionArguments.split(', ').map(name => ({ name }));
 
-  return snippetCompletion(template, {
-    label,
+  return {
+    name: functionName,
     type: 'function',
-    info,
-    detail
-  });
-}
-
-function autocompletion() {
-  return [
-    autocompletion$1({
-      override: [
-        variables,
-        builtins,
-        completeFromList(snippets.map(s => ({ ...s, boost: -1 }))),
-        pathExpression,
-        ...keywordCompletions
-      ]
-    })
-  ];
-}
-
-function language() {
-  return new LanguageSupport(feelLanguage, [ ]);
+    params,
+    info: () => {
+      return domify(`<div class="description">${description}<div>`);
+    },
+    boost: 0
+  };
 }
 
-var linter = [ linter$1(cmFeelLinter()) ];
-
-const baseTheme = EditorView.theme({
-  '& .cm-content': {
-    padding: '0px',
-  },
-  '& .cm-line': {
-    padding: '0px',
-  },
-  '&.cm-editor.cm-focused': {
-    outline: 'none',
-  },
-  '& .cm-completionInfo': {
-    whiteSpace: 'pre-wrap',
-    overflow: 'hidden',
-    textOverflow: 'ellipsis'
-  },
-
-  // Don't wrap whitespace for custom HTML
-  '& .cm-completionInfo > *': {
-    whiteSpace: 'normal'
-  },
-  '& .cm-completionInfo ul': {
-    margin: 0,
-    paddingLeft: '15px'
-  },
-  '& .cm-completionInfo pre': {
-    marginBottom: 0,
-    whiteSpace: 'pre-wrap'
-  },
-  '& .cm-completionInfo p': {
-    marginTop: 0,
-  },
-  '& .cm-completionInfo p:not(:last-of-type)': {
-    marginBottom: 0,
-  }
-});
-
-const highlightTheme = EditorView.baseTheme({
-  '& .variableName': {
-    color: '#10f'
-  },
-  '& .number': {
-    color: '#164'
-  },
-  '& .string': {
-    color: '#a11'
-  },
-  '& .bool': {
-    color: '#219'
-  },
-  '& .function': {
-    color: '#aa3731',
-    fontWeight: 'bold'
-  },
-  '& .control': {
-    color: '#708'
-  }
-});
-
-const syntaxClasses = syntaxHighlighting(
-  HighlightStyle.define([
-    { tag: tags$1.variableName, class: 'variableName' },
-    { tag: tags$1.name, class: 'variableName' },
-    { tag: tags$1.number, class: 'number' },
-    { tag: tags$1.string, class: 'string' },
-    { tag: tags$1.bool, class: 'bool' },
-    { tag: tags$1.function(tags$1.variableName), class: 'function' },
-    { tag: tags$1.function(tags$1.special(tags$1.variableName)), class: 'function' },
-    { tag: tags$1.controlKeyword, class: 'control' },
-    { tag: tags$1.operatorKeyword, class: 'control' }
-  ])
-);
+const camunda = parseBuiltins(camundaTags);
 
-var theme = [ baseTheme, highlightTheme, syntaxClasses ];
+/**
+ * @typedef { import('./core').Variable } Variable
+ */
 
 /**
- * @typedef {object} Variable
- * @property {string} name name or key of the variable
- * @property {string} [info] short information about the variable, e.g. type
- * @property {string} [detail] longer description of the variable content
- * @property {boolean} [isList] whether the variable is a list
- * @property {Array<Variable>} [schema] array of child variables if the variable is a context or list
- * @property {'function'|'variable'} [type] type of the variable
- * @property {Array<{name: string, type: string}>} [params] function parameters
+ * @typedef {object} Builtin
+ * @property {string} name
+ * @property {string} description
  */
 
-const autocompletionConf = new Compartment();
+const coreConf = new Compartment();
+const placeholderConf = new Compartment();
+
 
 /**
  * Creates a FEEL editor in the supplied container
@@ -874,6 +1043,7 @@ const autocompletionConf = new Compartment();
  * @param {Object} config
  * @param {DOMNode} config.container
  * @param {Extension[]} [config.extensions]
+ * @param {Dialect} [config.dialect='expression']
  * @param {DOMNode|String} [config.tooltipContainer]
  * @param {Function} [config.onChange]
  * @param {Function} [config.onKeyDown]
@@ -881,19 +1051,23 @@ const autocompletionConf = new Compartment();
  * @param {Boolean} [config.readOnly]
  * @param {String} [config.value]
  * @param {Variable[]} [config.variables]
+ * @param {Variable[]} [config.builtins]
  *
  * @returns {Object} editor
  */
 function FeelEditor({
   extensions: editorExtensions = [],
+  dialect = 'expression',
   container,
   contentAttributes = {},
   tooltipContainer,
   onChange = () => {},
   onKeyDown = () => {},
   onLint = () => {},
+  placeholder: placeholder$1 = '',
   readOnly = false,
   value = '',
+  builtins = camunda,
   variables = []
 }) {
 
@@ -934,21 +1108,25 @@ function FeelEditor({
   }) : [];
 
   const extensions = [
-    autocompletionConf.of(variablesFacet.of(variables)),
     autocompletion(),
+    coreConf.of(configure({
+      dialect,
+      builtins,
+      variables
+    })),
     bracketMatching(),
-    changeHandler,
+    indentOnInput(),
     closeBrackets(),
     EditorView.contentAttributes.of(contentAttributes),
-    indentOnInput(),
+    changeHandler,
     keyHandler,
     keymap.of([
       ...defaultKeymap,
     ]),
-    language(),
     linter,
     lintHandler,
     tooltipLayout,
+    placeholderConf.of(placeholder(placeholder$1)),
     theme,
     ...editorExtensions
   ];
@@ -960,7 +1138,7 @@ function FeelEditor({
   this._cmEditor = new EditorView({
     state: EditorState.create({
       doc: value,
-      extensions: extensions
+      extensions
     }),
     parent: container
   });
@@ -1013,12 +1191,35 @@ FeelEditor.prototype.getSelection = function() {
 
 /**
  * Set variables to be used for autocompletion.
+ *
  * @param {Variable[]} variables
- * @returns {void}
  */
 FeelEditor.prototype.setVariables = function(variables) {
+
+  const {
+    dialect,
+    builtins
+  } = get(this._cmEditor.state);
+
+  this._cmEditor.dispatch({
+    effects: [
+      coreConf.reconfigure(configure({
+        dialect,
+        builtins,
+        variables
+      }))
+    ]
+  });
+};
+
+/**
+ * Update placeholder text.
+ *
+ * @param {string} placeholder
+ */
+FeelEditor.prototype.setPlaceholder = function(placeholder$1) {
   this._cmEditor.dispatch({
-    effects: autocompletionConf.reconfigure(variablesFacet.of(variables))
+    effects: placeholderConf.reconfigure(placeholder(placeholder$1))
   });
 };