dequel-editor 0.6.1 → 0.8.5

package/dist/dequel-lang.js

@@ -1,172 +1,231 @@
-import { syntaxTree as b, LRLanguage as P, indentNodeProp as v, foldNodeProp as I, foldInside as N, HighlightStyle as O, LanguageSupport as V, syntaxHighlighting as w } from "@codemirror/language";
-import { Tag as s, tags as o, styleTags as A } from "@lezer/highlight";
-import { buildParser as E } from "@lezer/generator";
-import { Facet as L, StateEffect as D, StateField as Q } from "@codemirror/state";
-const T = E(`
+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 | IgnoredCondition }
-Condition { Field ":" Predicate }
-ExcludeCondition { "-" Field ":" Predicate }
-IgnoredCondition { "!" 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 }
 
-Predicate { Regex | Value | Command  }
-Command { Identifier "(" Argument ("," Argument)* ")" }
-Argument { Identifier | Number | String }
-Value { Identifier | Number | String }
+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 }
+
+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 }
-  Function { Identifier }
+
+  @precedence { DynamicValue, DateLiteral, Number, Identifier }
+
   Identifier { $[a-zA-Z_]+ ("." $[a-zA-Z_]+)* }
-  Number { std.digit+ }
-  String { '"' !["]* '"' }
-  Regex { RegexContent (RegexFlag)* }
-  RegexFlag { std.asciiLetter+ }
-  RegexContent { "/" (![/] | "\\/")*  "/" }
+
   Comment { "#" (![
 ])* }
+
+  "(" ")" "{" "}" "[" "]" "," "-" "&&" "||"
 }
 `), t = {
-  Condition: s.define(o.keyword),
-  Field: s.define(o.propertyName),
-  Command: o.function(o.variableName),
-  Predicate: s.define(o.variableName),
-  Value: s.define(o.attributeValue),
-  Operator: s.define(o.operator),
-  Regex: s.define(o.regexp),
-  RegexContent: s.define(o.regexp)
-}, q = L.define(), k = (e, i) => {
-  for (; i.parent; ) {
-    if (i.parent.name === e)
-      return i.parent;
-    i = i.parent;
+  Condition: f.define(i.keyword),
+  Field: f.define(i.propertyName),
+  Command: i.function(i.variableName),
+  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 B(e, i, n) {
-  let d = i;
-  for (const c of e) {
-    const a = d.fields.find((l) => l.label === c);
-    if (a?.type !== "relationship" || !a.target)
+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;
-    d = await n.get(a.target);
+    o = await a.get(r.schema);
   }
-  return d;
+  return o;
 }
-const H = D.define(), $ = Q.define({
-  create: () => ({ fields: [] }),
-  update: (e, i) => {
-    for (const n of i.effects)
-      if (n.is(H))
-        return n.value;
+const T = j.define(), $ = w.define({
+  create: () => ({ fields: {} }),
+  update: (e, n) => {
+    for (const a of n.effects)
+      if (a.is(T))
+        return a.value;
     return e;
   }
-}), z = S.data.of({
+}), H = b.data.of({
   autocomplete: async (e) => {
-    const n = b(e.state).resolveInner(e.pos, -1), d = e.state.sliceDoc(n.from, e.pos), c = /[\w.]*$/.exec(d);
-    if (!c && !e.explicit) return null;
-    const a = c ? n.from + c.index : e.pos, l = e.state.field($, !1), C = e.state.facet(q)[0]?.schemaCache, h = k("Condition", n), g = h?.getChild("Field"), y = h?.getChild(":");
-    if (g && y && e.pos > y.to) {
-      const m = e.state.doc.sliceString(g.from, g.to), f = l?.values?.[m];
-      if (f?.length) {
-        const p = f.map((r) => ({
-          label: r,
+    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,
-          options: p
+          from: r,
+          options: g
         };
       }
     }
-    if (n.name === "Field" && l?.fields?.length) {
-      const m = e.state.doc.sliceString(n.from, e.pos), f = m.split(".");
-      if (f.length > 1 && C) {
-        const r = f.slice(0, -1), F = n.from + m.lastIndexOf(".") + 1, x = await B(
-          r,
-          l,
-          C
+    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,
+          s,
+          h
         );
-        if (x) {
-          const R = x.fields.map((u) => ({
-            label: u.label,
-            type: u.type,
-            info: u.info
+        if (O) {
+          const V = Object.entries(O.fields).map(([D, S]) => ({
+            label: D,
+            type: S.type,
+            info: S.info
           }));
           return {
-            from: F,
-            options: R
+            from: m,
+            options: V
           };
         }
         return {
-          from: F,
+          from: m,
           options: []
         };
       }
-      const p = l.fields.map((r) => ({
-        label: r.label,
-        type: r.type,
-        info: r.info
+      const g = Object.entries(s.fields).map(([c, m]) => ({
+        label: c,
+        type: m.type,
+        info: m.info
       }));
       return {
-        from: a,
-        options: p
+        from: r,
+        options: g
       };
     }
-    return n.name === "Field" ? {
-      from: a,
+    return a.name === "Field" ? {
+      from: r,
       options: []
     } : null;
   }
-}), Z = O.define([
+}), 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.Regex, class: "cnd-val cnd-rgx cnd-rgx-f" },
-  { tag: o.string, class: "string" },
-  { tag: o.lineComment, class: "comment" }
-]), _ = T.configure({
+  { tag: t.DynamicValue, class: "cnd-val cnd-dynamic" },
+  { tag: i.string, class: "string" },
+  { tag: i.number, class: "cnd-val" },
+  { tag: i.lineComment, class: "comment" }
+]), Z = Q.configure({
   props: [
-    A({
+    E({
+      // Condition structure
       "Condition/:": t.Operator,
       "ExcludeCondition/:": t.Operator,
       "Condition/Field/...": t.Field,
-      "Condition/Predicate/RegexContent!": t.RegexContent,
+      Field: t.Field,
+      // Command and values
       "Command!": t.Command,
+      "Value!": t.Value,
       "Separator!": t.Operator,
-      Regex: t.Regex,
-      Comment: o.lineComment,
-      Field: t.Field,
-      "Value!": t.Value
+      // 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
     }),
     v.add({
-      Query: (e) => e.column(e.node.from) + e.unit
+      Query: (e) => e.column(e.node.from) + e.unit,
+      ObjectBlock: (e) => e.column(e.node.from) + e.unit
     }),
-    I.add({
-      Query: N
+    F.add({
+      Query: P,
+      ObjectBlock: P
     })
   ]
-}), S = P.define({
-  parser: _,
+}), b = I.define({
+  parser: Z,
   languageData: {}
 });
-function K() {
-  return new V(S, [
-    w(Z),
-    z
+function X() {
+  return new L(b, [
+    k(G),
+    H
   ]);
 }
 export {
-  K as DequelLang,
-  S as dequelParser
+  X as DequelLang,
+  b as dequelParser
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dequel-editor",
-  "version": "0.6.1",
+  "version": "0.8.5",
   "description": "CodeMirror-based editor for Dequel query language",
   "type": "module",
   "main": "./dist/dequel-editor.js",
@@ -57,6 +57,7 @@
     "eslint": "^8.57.1",
     "gettext-parser": "^8.0.0",
     "http-proxy-middleware": "^3.0.5",
+    "jsdom": "^28.1.0",
     "tailwindcss": "^4.1.18",
     "tsx": "^4.19.4",
     "typescript": "^5.9.3",