dequel-editor 0.7.0 → 0.8.5

package/dist/dequel-lang.js

@@ -1,162 +1,231 @@
-import { syntaxTree as P, LRLanguage as O, indentNodeProp as I, foldNodeProp as V, foldInside as w, HighlightStyle as A, LanguageSupport as E, syntaxHighlighting as D } from "@codemirror/language";
-import { Tag as m, tags as i, styleTags as L } from "@lezer/highlight";
-import { buildParser as Q } from "@lezer/generator";
-import { Facet as T, StateEffect as k, StateField as q } from "@codemirror/state";
-const j = Q(`
+import { syntaxTree as N, LRLanguage as I, indentNodeProp as v, foldNodeProp as F, foldInside as P, HighlightStyle as A, LanguageSupport as L, syntaxHighlighting as k } from "@codemirror/language";
+import { tags as i, Tag as f, styleTags as E } from "@lezer/highlight";
+import { buildParser as W } from "@lezer/generator";
+import { Facet as B, StateEffect as j, StateField as w } from "@codemirror/state";
+const Q = W(`
 @top QueryList { Query }
-@skip { "
+@skip { " " | "	" | "
 " | Comment }
+@detectDelim
 
 Query {
-  anyCondition ((" " | "	")+  anyCondition)*
+  queryElement+
 }
 
-anyCondition { Condition | ExcludeCondition }
-Condition { Field ":" Predicate }
-ExcludeCondition { "-" Field ":" Predicate }
+queryElement {
+  logicalOp | Condition | ExcludeCondition | Group | ObjectBlock
+}
+
+logicalOp { And | Or }
+
+And { "&&" | andWord }
+Or { "||" | orWord }
+andWord[@name=And] { @specialize<Identifier, "AND"> | @specialize<Identifier, "and"> }
+orWord[@name=Or] { @specialize<Identifier, "OR"> | @specialize<Identifier, "or"> }
+
+Group { "(" Query ")" }
+
+ObjectBlock { Identifier "{" Query "}" }
+
+Condition { field ":" Predicate }
+ExcludeCondition { "-" field ":" Predicate }
+
+field[@name=Field] { Identifier }
+
+Predicate {
+  NegatedPredicate |
+  RangePredicate |
+  ComparisonPredicate |
+  BracketPredicate |
+  ShorthandPredicate |
+  Command |
+  SimplePredicate
+}
+
+NegatedPredicate { Not (ComparisonPredicate | ShorthandPredicate | SimplePredicate) }
+ComparisonPredicate { CompareOp Value }
+RangePredicate { Value RangeSep Value }
+BracketPredicate { "[" Value ("," Value)* "]" }
+ShorthandPredicate { (Contains | StartsWith | EndsWith) Value }
+SimplePredicate { Value }
+
+Command { Identifier ~ambig "(" ArgList? ")" }
+ArgList { Argument ("," Argument)* }
+Argument { Identifier | Number | String | DateLiteral | DynamicValue }
 
-Predicate { Value | Command  }
-Command { Identifier "(" Argument ("," Argument)* ")" }
-Argument { Identifier | Number | String }
-Value { Identifier | Number | String }
+Value { DynamicValue | DateLiteral | Number | String | Identifier ~ambig }
 
 @tokens {
+  CompareOp { ">=" | "<=" | ">" | "<" }
+  RangeSep { ".." }
+
+  Contains { "*" }
+  StartsWith { "^" }
+  EndsWith { "$" }
+  Not { "!" }
+
+  DynamicValue { "@" ("today" | "tomorrow" | "yesterday" | "this-year" | "this-month-start" | "this-month-end" | "this-month") }
+  DateLiteral { std.digit std.digit std.digit std.digit "-" std.digit std.digit ("-" std.digit std.digit)? }
+
+  Number { "-"? std.digit+ ("." std.digit+)? }
+  String { '"' !["]* '"' }
+
   ":"
-  Field { Identifier }
+
+  @precedence { DynamicValue, DateLiteral, Number, Identifier }
+
   Identifier { $[a-zA-Z_]+ ("." $[a-zA-Z_]+)* }
-  Number { std.digit+ }
-  String { '"' !["]* '"' }
+
   Comment { "#" (![
 ])* }
+
+  "(" ")" "{" "}" "[" "]" "," "-" "&&" "||"
 }
-`), n = {
-  Condition: m.define(i.keyword),
-  Field: m.define(i.propertyName),
+`), t = {
+  Condition: f.define(i.keyword),
+  Field: f.define(i.propertyName),
   Command: i.function(i.variableName),
-  Predicate: m.define(i.variableName),
-  Value: m.define(i.attributeValue),
-  Operator: m.define(i.operator)
-}, B = T.define(), H = (e, o) => {
-  for (; o.parent; ) {
-    if (o.parent.name === e)
-      return o.parent;
-    o = o.parent;
+  Predicate: f.define(i.variableName),
+  Value: f.define(i.attributeValue),
+  Operator: f.define(i.operator),
+  DynamicValue: i.special(i.variableName)
+}, R = B.define(), q = (e, n) => {
+  for (; n.parent; ) {
+    if (n.parent.name === e)
+      return n.parent;
+    n = n.parent;
   }
   return null;
 };
-async function $(e, o, t) {
-  let r = o;
-  for (const s of e) {
-    const a = r.fields[s];
-    if (a?.type !== "relationship" || !a.schema)
+async function z(e, n, a) {
+  let o = n;
+  for (const d of e) {
+    const r = o.fields[d];
+    if (r?.type !== "relationship" || !r.schema)
       return null;
-    r = await t.get(a.schema);
+    o = await a.get(r.schema);
   }
-  return r;
+  return o;
 }
-const z = k.define(), Z = q.define({
+const T = j.define(), $ = w.define({
   create: () => ({ fields: {} }),
-  update: (e, o) => {
-    for (const t of o.effects)
-      if (t.is(z))
-        return t.value;
+  update: (e, n) => {
+    for (const a of n.effects)
+      if (a.is(T))
+        return a.value;
     return e;
   }
-}), _ = b.data.of({
+}), H = b.data.of({
   autocomplete: async (e) => {
-    const t = P(e.state).resolveInner(e.pos, -1), r = e.state.sliceDoc(t.from, e.pos), s = /[\w.]*$/.exec(r);
-    if (!s && !e.explicit) return null;
-    const a = s ? t.from + s.index : e.pos, l = e.state.field(Z, !1), h = e.state.facet(B)[0]?.schemaCache, C = H("Condition", t), u = C?.getChild("Field"), y = C?.getChild(":");
-    if (u && y && e.pos > y.to) {
-      const p = e.state.doc.sliceString(u.from, u.to), d = l?.fields[p]?.values;
-      if (d?.length) {
-        const g = d.map((c) => ({
+    const a = N(e.state).resolveInner(e.pos, -1), o = e.state.sliceDoc(a.from, e.pos), d = /[\w.]*$/.exec(o);
+    if (!d && !e.explicit) return null;
+    const r = d ? a.from + d.index : e.pos, s = e.state.field($, !1), h = e.state.facet(R)[0]?.schemaCache, y = q("Condition", a), u = y?.getChild("Field"), C = y?.getChild(":");
+    if (u && C && e.pos > C.to) {
+      const p = e.state.doc.sliceString(u.from, u.to), l = s?.fields[p]?.values;
+      if (l?.length) {
+        const g = l.map((c) => ({
           label: c,
           type: "value"
         }));
         return {
-          from: a,
+          from: r,
           options: g
         };
       }
     }
-    if (t.name === "Field" && l && Object.keys(l.fields).length) {
-      const p = e.state.doc.sliceString(t.from, e.pos), d = p.split(".");
-      if (d.length > 1 && h) {
-        const c = d.slice(0, -1), f = t.from + p.lastIndexOf(".") + 1, F = await $(
+    if (a.name === "Field" && s && Object.keys(s.fields).length) {
+      const p = e.state.doc.sliceString(a.from, e.pos), l = p.split(".");
+      if (l.length > 1 && h) {
+        const c = l.slice(0, -1), m = a.from + p.lastIndexOf(".") + 1, O = await z(
           c,
-          l,
+          s,
           h
         );
-        if (F) {
-          const v = Object.entries(F.fields).map(([N, S]) => ({
-            label: N,
+        if (O) {
+          const V = Object.entries(O.fields).map(([D, S]) => ({
+            label: D,
             type: S.type,
             info: S.info
           }));
           return {
-            from: f,
-            options: v
+            from: m,
+            options: V
           };
         }
         return {
-          from: f,
+          from: m,
           options: []
         };
       }
-      const g = Object.entries(l.fields).map(([c, f]) => ({
+      const g = Object.entries(s.fields).map(([c, m]) => ({
         label: c,
-        type: f.type,
-        info: f.info
+        type: m.type,
+        info: m.info
       }));
       return {
-        from: a,
+        from: r,
         options: g
       };
     }
-    return t.name === "Field" ? {
-      from: a,
+    return a.name === "Field" ? {
+      from: r,
       options: []
     } : null;
   }
-}), M = A.define([
-  { tag: n.Condition, class: "cnd" },
-  { tag: n.Operator, class: "cnd-op" },
-  { tag: n.Value, class: "cnd-val" },
-  { tag: n.Command, class: "cnd-val cnd-cmd" },
-  { tag: n.Field, class: "cnd-fld" },
+}), G = A.define([
+  { tag: t.Condition, class: "cnd" },
+  { tag: t.Operator, class: "cnd-op" },
+  { tag: t.Value, class: "cnd-val" },
+  { tag: t.Command, class: "cnd-val cnd-cmd" },
+  { tag: t.Field, class: "cnd-fld" },
+  { tag: t.DynamicValue, class: "cnd-val cnd-dynamic" },
   { tag: i.string, class: "string" },
+  { tag: i.number, class: "cnd-val" },
   { tag: i.lineComment, class: "comment" }
-]), R = j.configure({
+]), Z = Q.configure({
   props: [
-    L({
-      "Condition/:": n.Operator,
-      "ExcludeCondition/:": n.Operator,
-      "Condition/Field/...": n.Field,
-      "Command!": n.Command,
-      "Separator!": n.Operator,
-      Comment: i.lineComment,
-      Field: n.Field,
-      "Value!": n.Value
+    E({
+      // Condition structure
+      "Condition/:": t.Operator,
+      "ExcludeCondition/:": t.Operator,
+      "Condition/Field/...": t.Field,
+      Field: t.Field,
+      // Command and values
+      "Command!": t.Command,
+      "Value!": t.Value,
+      "Separator!": t.Operator,
+      // Logical operators
+      "And Or": t.Operator,
+      // Comparison and range operators
+      "CompareOp Contains StartsWith EndsWith Not RangeSep": t.Operator,
+      // Special value types
+      DynamicValue: t.DynamicValue,
+      DateLiteral: i.number,
+      // Object blocks
+      "ObjectBlock/Identifier": t.Field,
+      // Comments
+      Comment: i.lineComment
     }),
-    I.add({
-      Query: (e) => e.column(e.node.from) + e.unit
+    v.add({
+      Query: (e) => e.column(e.node.from) + e.unit,
+      ObjectBlock: (e) => e.column(e.node.from) + e.unit
     }),
-    V.add({
-      Query: w
+    F.add({
+      Query: P,
+      ObjectBlock: P
     })
   ]
-}), b = O.define({
-  parser: R,
+}), b = I.define({
+  parser: Z,
   languageData: {}
 });
-function U() {
-  return new E(b, [
-    D(M),
-    _
+function X() {
+  return new L(b, [
+    k(G),
+    H
   ]);
 }
 export {
-  U as DequelLang,
+  X as DequelLang,
   b as dequelParser
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dequel-editor",
-  "version": "0.7.0",
+  "version": "0.8.5",
   "description": "CodeMirror-based editor for Dequel query language",
   "type": "module",
   "main": "./dist/dequel-editor.js",