@sendbird/actionbook-core 0.10.1 → 0.10.2

package/dist/ui/index.d.ts

@@ -426,4 +426,10 @@ declare function toProseMirrorJSON(doc: DocumentNode): JSONContent;
  */
 declare function astNodesToJSONContent(nodes: (InlineNode | BlockNode)[]): JSONContent[];
 
-export { type ActionbookPlugin, ActionbookRenderer, type ActionbookRendererProps, DocumentTreeView, type DocumentTreeViewProps, EditorShell, type EditorShellProps, type EditorViewConfig, type EditorViewHandle, FloatingMenu, type FloatingMenuProps, type InlineSuggestContext, type InlineSuggestProvider, type InlineSuggestState, JUMP_POINT_ADJACENT_SPEC, JinjaTreeView, type JinjaTreeViewProps, type NodeViewFactory, type ReactNodeViewOptions, type ReactNodeViewProps, type SlashCommandItem, SlashCommandMenu, type SlashCommandMenuProps, type SlashCommandState, actionbookSchema, astNodesToJSONContent, convertBlock, convertInline, createDragHandlePlugin, createHistoryPlugin, createInlineSuggestPlugin, createInlineToolTagNodeViewPlugin, createInputRulesPlugin, createJinjaDecorationPlugin, createJinjaIfBlockPlugin, createJumpPointAdjacentPlugin, createJumpPointNodeViewPlugin, createJumpPointValidationPlugin, createKeymapPlugin, createLinkPlugin, createMarkdownClipboardPlugin, createNoteBlockPlugin, createPlaceholderPlugin, createPluginArray, createReactNodeView, createSlashCommandPlugin, createTodoNodeViewPlugin, hasBrokenAnchorRefs, hasDuplicateJumpPoints, inlineSuggestKey, slashCommandKey, toProseMirrorJSON, useEditorView };
+/**
+ * Check if any jinjaIfBranch in the editor has an invalid (non-empty) condition.
+ * Used to block save when conditions have syntax errors.
+ */
+declare function hasInvalidJinjaConditions(state: EditorState): boolean;
+
+export { type ActionbookPlugin, ActionbookRenderer, type ActionbookRendererProps, DocumentTreeView, type DocumentTreeViewProps, EditorShell, type EditorShellProps, type EditorViewConfig, type EditorViewHandle, FloatingMenu, type FloatingMenuProps, type InlineSuggestContext, type InlineSuggestProvider, type InlineSuggestState, JUMP_POINT_ADJACENT_SPEC, JinjaTreeView, type JinjaTreeViewProps, type NodeViewFactory, type ReactNodeViewOptions, type ReactNodeViewProps, type SlashCommandItem, SlashCommandMenu, type SlashCommandMenuProps, type SlashCommandState, actionbookSchema, astNodesToJSONContent, convertBlock, convertInline, createDragHandlePlugin, createHistoryPlugin, createInlineSuggestPlugin, createInlineToolTagNodeViewPlugin, createInputRulesPlugin, createJinjaDecorationPlugin, createJinjaIfBlockPlugin, createJumpPointAdjacentPlugin, createJumpPointNodeViewPlugin, createJumpPointValidationPlugin, createKeymapPlugin, createLinkPlugin, createMarkdownClipboardPlugin, createNoteBlockPlugin, createPlaceholderPlugin, createPluginArray, createReactNodeView, createSlashCommandPlugin, createTodoNodeViewPlugin, hasBrokenAnchorRefs, hasDuplicateJumpPoints, hasInvalidJinjaConditions, inlineSuggestKey, slashCommandKey, toProseMirrorJSON, useEditorView };

package/dist/ui/index.js

@@ -5149,6 +5149,320 @@ function analyzeJinjaBlocks(doc2) {
   });
 }
 
+// src/jinja/evaluator.ts
+var KEYWORDS2 = {
+  and: "AND",
+  or: "OR",
+  not: "NOT",
+  in: "IN",
+  is: "IS",
+  True: "BOOL",
+  False: "BOOL",
+  true: "BOOL",
+  false: "BOOL",
+  None: "NONE",
+  null: "NONE"
+};
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    if (/\s/.test(input[i])) {
+      i++;
+      continue;
+    }
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      let str = "";
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\" && i + 1 < input.length) {
+          str += input[i + 1];
+          i += 2;
+        } else {
+          str += input[i];
+          i++;
+        }
+      }
+      if (i >= input.length) return { tokens: [], error: "Unterminated string literal" };
+      i++;
+      tokens.push({ type: "STRING", value: str });
+      continue;
+    }
+    if (/[0-9]/.test(input[i]) || input[i] === "-" && i + 1 < input.length && /[0-9]/.test(input[i + 1]) && (tokens.length === 0 || ["AND", "OR", "NOT", "EQ", "NEQ", "LT", "GT", "LTE", "GTE", "LPAREN", "IN", "IS"].includes(tokens[tokens.length - 1].type))) {
+      let num = "";
+      if (input[i] === "-") {
+        num = "-";
+        i++;
+      }
+      while (i < input.length && /[0-9]/.test(input[i])) {
+        num += input[i];
+        i++;
+      }
+      if (i < input.length && input[i] === ".") {
+        num += ".";
+        i++;
+        while (i < input.length && /[0-9]/.test(input[i])) {
+          num += input[i];
+          i++;
+        }
+      }
+      tokens.push({ type: "NUMBER", value: num });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(input[i])) {
+      let ident = "";
+      while (i < input.length && /[a-zA-Z0-9_.]/.test(input[i])) {
+        ident += input[i];
+        i++;
+      }
+      const kwType = KEYWORDS2[ident];
+      if (kwType) {
+        tokens.push({ type: kwType, value: ident });
+      } else {
+        tokens.push({ type: "IDENT", value: ident });
+      }
+      continue;
+    }
+    if (i + 1 < input.length) {
+      const two = input[i] + input[i + 1];
+      if (two === "==") {
+        tokens.push({ type: "EQ", value: "==" });
+        i += 2;
+        continue;
+      }
+      if (two === "!=") {
+        tokens.push({ type: "NEQ", value: "!=" });
+        i += 2;
+        continue;
+      }
+      if (two === "<=") {
+        tokens.push({ type: "LTE", value: "<=" });
+        i += 2;
+        continue;
+      }
+      if (two === ">=") {
+        tokens.push({ type: "GTE", value: ">=" });
+        i += 2;
+        continue;
+      }
+    }
+    if (input[i] === "<") {
+      tokens.push({ type: "LT", value: "<" });
+      i++;
+      continue;
+    }
+    if (input[i] === ">") {
+      tokens.push({ type: "GT", value: ">" });
+      i++;
+      continue;
+    }
+    if (input[i] === "(") {
+      tokens.push({ type: "LPAREN", value: "(" });
+      i++;
+      continue;
+    }
+    if (input[i] === ")") {
+      tokens.push({ type: "RPAREN", value: ")" });
+      i++;
+      continue;
+    }
+    return { tokens: [], error: `Unexpected character: ${input[i]}` };
+  }
+  tokens.push({ type: "EOF", value: "" });
+  return { tokens };
+}
+var Parser = class {
+  pos = 0;
+  tokens;
+  variables;
+  constructor(tokens, variables) {
+    this.tokens = tokens;
+    this.variables = variables;
+  }
+  peek() {
+    return this.tokens[this.pos] ?? { type: "EOF", value: "" };
+  }
+  advance() {
+    const t = this.tokens[this.pos];
+    this.pos++;
+    return t;
+  }
+  expect(type) {
+    const t = this.peek();
+    if (t.type !== type) {
+      throw new Error(`Expected ${type}, got ${t.type}`);
+    }
+    return this.advance();
+  }
+  // Grammar (precedence low→high):
+  //   expr     → or_expr
+  //   or_expr  → and_expr ('or' and_expr)*
+  //   and_expr → not_expr ('and' not_expr)*
+  //   not_expr → 'not' not_expr | cmp_expr
+  //   cmp_expr → primary (('=='|'!='|'<'|'>'|'<='|'>='|'in'|'is'|'is not') primary)?
+  //   primary  → STRING | NUMBER | BOOL | NONE | IDENT | '(' expr ')'
+  evaluate() {
+    const result = this.orExpr();
+    if (this.peek().type !== "EOF") {
+      throw new Error(`Unexpected token: ${this.peek().value}`);
+    }
+    return result;
+  }
+  orExpr() {
+    let left = this.andExpr();
+    while (this.peek().type === "OR") {
+      this.advance();
+      const right = this.andExpr();
+      left = isTruthy(left) || isTruthy(right);
+    }
+    return left;
+  }
+  andExpr() {
+    let left = this.notExpr();
+    while (this.peek().type === "AND") {
+      this.advance();
+      const right = this.notExpr();
+      left = isTruthy(left) && isTruthy(right);
+    }
+    return left;
+  }
+  notExpr() {
+    if (this.peek().type === "NOT") {
+      this.advance();
+      const val = this.notExpr();
+      return !isTruthy(val);
+    }
+    return this.cmpExpr();
+  }
+  cmpExpr() {
+    const left = this.primary();
+    const op = this.peek().type;
+    switch (op) {
+      case "EQ":
+        this.advance();
+        return looseEqual(left, this.primary());
+      case "NEQ":
+        this.advance();
+        return !looseEqual(left, this.primary());
+      case "LT":
+        this.advance();
+        return toNumber(left) < toNumber(this.primary());
+      case "GT":
+        this.advance();
+        return toNumber(left) > toNumber(this.primary());
+      case "LTE":
+        this.advance();
+        return toNumber(left) <= toNumber(this.primary());
+      case "GTE":
+        this.advance();
+        return toNumber(left) >= toNumber(this.primary());
+      case "IN": {
+        this.advance();
+        const collection = this.primary();
+        if (Array.isArray(collection)) {
+          return collection.some((item) => looseEqual(item, left));
+        }
+        if (typeof collection === "string" && typeof left === "string") {
+          return collection.includes(left);
+        }
+        return false;
+      }
+      case "IS": {
+        this.advance();
+        if (this.peek().type === "NOT") {
+          this.advance();
+          return !looseEqual(left, this.primary());
+        }
+        return looseEqual(left, this.primary());
+      }
+      default:
+        return left;
+    }
+  }
+  primary() {
+    const t = this.peek();
+    switch (t.type) {
+      case "STRING":
+        this.advance();
+        return t.value;
+      case "NUMBER":
+        this.advance();
+        return parseFloat(t.value);
+      case "BOOL":
+        this.advance();
+        return t.value === "True" || t.value === "true";
+      case "NONE":
+        this.advance();
+        return null;
+      case "IDENT": {
+        this.advance();
+        return this.resolveVariable(t.value);
+      }
+      case "LPAREN": {
+        this.advance();
+        const val = this.orExpr();
+        this.expect("RPAREN");
+        return val;
+      }
+      default:
+        throw new Error(`Unexpected token in primary: ${t.type} "${t.value}"`);
+    }
+  }
+  resolveVariable(name) {
+    const entry = this.variables.get(name);
+    if (entry === void 0) {
+      return null;
+    }
+    switch (entry.type) {
+      case "string":
+        return String(entry.value);
+      case "number":
+        return Number(entry.value);
+      case "boolean":
+        return entry.value === true || entry.value === "true";
+      default:
+        return String(entry.value);
+    }
+  }
+};
+function isTruthy(v) {
+  if (v === null || v === void 0) return false;
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v.length > 0;
+  if (Array.isArray(v)) return v.length > 0;
+  return true;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a === "number" && typeof b === "string") return a === parseFloat(b);
+  if (typeof a === "string" && typeof b === "number") return parseFloat(a) === b;
+  return false;
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return parseFloat(v) || 0;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  return 0;
+}
+function validateCondition(condition) {
+  const trimmed = condition.trim();
+  if (trimmed === "") return { valid: true };
+  const { tokens, error: tokenError } = tokenize(trimmed);
+  if (tokenError) return { valid: false, error: tokenError };
+  if (tokens.length === 0) return { valid: false, error: "Empty expression" };
+  try {
+    const parser = new Parser(tokens, /* @__PURE__ */ new Map());
+    parser.evaluate();
+    return { valid: true };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "Invalid expression";
+    return { valid: false, error: msg };
+  }
+}
+
 // src/tree/documentTree.ts
 var MAX_DEPTH6 = 128;
 var END_ACTION_RESOURCE_IDS = /* @__PURE__ */ new Set([
@@ -6116,6 +6430,18 @@ var JINJA_STYLES = `
   letter-spacing: -0.3px;
 }
 
+.jinja-branch-condition-invalid {
+  text-decoration: wavy underline #D9352C;
+  text-underline-offset: 3px;
+}
+
+.jinja-condition-error-icon {
+  color: #D9352C;
+  margin-left: 4px;
+  font-size: 12px;
+  flex-shrink: 0;
+}
+
 .jinja-token-variable {
   color: #4141B2;
 }
@@ -6564,11 +6890,14 @@ function ConditionDisplay({
       }
     );
   }
+  const validation = condition.length > 0 ? validateCondition(condition) : null;
+  const isInvalid = validation != null && !validation.valid;
   return /* @__PURE__ */ jsx6(
     "button",
     {
       type: "button",
-      className: "jinja-branch-condition",
+      className: `jinja-branch-condition${isInvalid ? " jinja-branch-condition-invalid" : ""}`,
+      title: isInvalid ? validation.error : void 0,
       onMouseDown: (event) => event.preventDefault(),
       onClick: () => {
         if (editable) {
@@ -6576,7 +6905,10 @@ function ConditionDisplay({
           setIsEditing(true);
         }
       },
-      children: condition.length > 0 ? renderCondition(condition) : /* @__PURE__ */ jsx6("span", { className: "jinja-condition-placeholder", children: CONDITION_PLACEHOLDER })
+      children: condition.length > 0 ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+        renderCondition(condition),
+        isInvalid && /* @__PURE__ */ jsx6("span", { className: "jinja-condition-error-icon", children: "\u26A0" })
+      ] }) : /* @__PURE__ */ jsx6("span", { className: "jinja-condition-placeholder", children: CONDITION_PLACEHOLDER })
     }
   );
 }
@@ -9971,6 +10303,22 @@ function createInlineSuggestPlugin(provider, endpoint, options) {
     ]
   };
 }
+
+// src/ui/bridge/jinjaValidation.ts
+function hasInvalidJinjaConditions(state) {
+  let found = false;
+  state.doc.descendants((node) => {
+    if (found) return false;
+    if (node.type.name === "jinjaIfBranch") {
+      const condition = String(node.attrs.condition ?? "");
+      if (condition && !validateCondition(condition).valid) {
+        found = true;
+      }
+      return false;
+    }
+  });
+  return found;
+}
 export {
   ActionbookRenderer,
   DocumentTreeView,
@@ -10004,6 +10352,7 @@ export {
   createTodoNodeViewPlugin,
   hasBrokenAnchorRefs,
   hasDuplicateJumpPoints,
+  hasInvalidJinjaConditions,
   inlineSuggestKey,
   slashCommandKey,
   toProseMirrorJSON,