dequel-editor 0.6.0 → 0.7.0

package/dist/dequel-lang.js

@@ -1,8 +1,8 @@
-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 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(`
 @top QueryList { Query }
 @skip { "
 " | Comment }
@@ -11,12 +11,11 @@ Query {
   anyCondition ((" " | "	")+  anyCondition)*
 }
 
-anyCondition { Condition | ExcludeCondition | IgnoredCondition }
+anyCondition { Condition | ExcludeCondition }
 Condition { Field ":" Predicate }
 ExcludeCondition { "-" Field ":" Predicate }
-IgnoredCondition { "!" Field ":" Predicate }
 
-Predicate { Regex | Value | Command  }
+Predicate { Value | Command  }
 Command { Identifier "(" Argument ("," Argument)* ")" }
 Argument { Identifier | Number | String }
 Value { Identifier | Number | String }
@@ -24,149 +23,140 @@ Value { Identifier | Number | String }
 @tokens {
   ":"
   Field { Identifier }
-  Function { 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;
+`), n = {
+  Condition: m.define(i.keyword),
+  Field: m.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;
   }
   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 $(e, o, t) {
+  let r = o;
+  for (const s of e) {
+    const a = r.fields[s];
+    if (a?.type !== "relationship" || !a.schema)
       return null;
-    d = await n.get(a.target);
+    r = await t.get(a.schema);
   }
-  return d;
+  return r;
 }
-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 z = k.define(), Z = q.define({
+  create: () => ({ fields: {} }),
+  update: (e, o) => {
+    for (const t of o.effects)
+      if (t.is(z))
+        return t.value;
     return e;
   }
-}), z = S.data.of({
+}), _ = 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 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) => ({
+          label: c,
           type: "value"
         }));
         return {
           from: a,
-          options: p
+          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,
+    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 $(
+          c,
           l,
-          C
+          h
         );
-        if (x) {
-          const R = x.fields.map((u) => ({
-            label: u.label,
-            type: u.type,
-            info: u.info
+        if (F) {
+          const v = Object.entries(F.fields).map(([N, S]) => ({
+            label: N,
+            type: S.type,
+            info: S.info
           }));
           return {
-            from: F,
-            options: R
+            from: f,
+            options: v
           };
         }
         return {
-          from: F,
+          from: f,
           options: []
         };
       }
-      const p = l.fields.map((r) => ({
-        label: r.label,
-        type: r.type,
-        info: r.info
+      const g = Object.entries(l.fields).map(([c, f]) => ({
+        label: c,
+        type: f.type,
+        info: f.info
       }));
       return {
         from: a,
-        options: p
+        options: g
       };
     }
-    return n.name === "Field" ? {
+    return t.name === "Field" ? {
       from: a,
       options: []
     } : null;
   }
-}), Z = O.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({
+}), 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" },
+  { tag: i.string, class: "string" },
+  { tag: i.lineComment, class: "comment" }
+]), R = j.configure({
   props: [
-    A({
-      "Condition/:": t.Operator,
-      "ExcludeCondition/:": t.Operator,
-      "Condition/Field/...": t.Field,
-      "Condition/Predicate/RegexContent!": t.RegexContent,
-      "Command!": t.Command,
-      "Separator!": t.Operator,
-      Regex: t.Regex,
-      Comment: o.lineComment,
-      Field: t.Field,
-      "Value!": t.Value
+    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
     }),
-    v.add({
+    I.add({
       Query: (e) => e.column(e.node.from) + e.unit
     }),
-    I.add({
-      Query: N
+    V.add({
+      Query: w
     })
   ]
-}), S = P.define({
-  parser: _,
+}), b = O.define({
+  parser: R,
   languageData: {}
 });
-function K() {
-  return new V(S, [
-    w(Z),
-    z
+function U() {
+  return new E(b, [
+    D(M),
+    _
   ]);
 }
 export {
-  K as DequelLang,
-  S as dequelParser
+  U as DequelLang,
+  b as dequelParser
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dequel-editor",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CodeMirror-based editor for Dequel query language",
   "type": "module",
   "main": "./dist/dequel-editor.js",
@@ -40,14 +40,14 @@
     "@lezer/common": "^1.5.0",
     "@lezer/generator": "^1.8.0",
     "@lezer/highlight": "^1.2.3",
-    "@preact/preset-vite": "^2.10.3",
-    "@tailwindcss/vite": "^4.1.18",
     "axios": "^1.13.4",
     "preact": "^10.28.3"
   },
   "devDependencies": {
     "@open-wc/testing": "^4.0.0",
+    "@preact/preset-vite": "^2.10.3",
     "@remcovaes/web-test-runner-vite-plugin": "^1.4.0",
+    "@tailwindcss/vite": "^4.1.18",
     "@types/node": "^20.19.31",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
@@ -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",