@persona/design-system 0.5.0 → 0.6.0

package/dist/components/SmartTextInput/parser/smart-text/grammar.pegjs

@@ -0,0 +1,154 @@
+/**
+ * ===========================================================================
+ * Run bin/smart_text_input_parser/generate.sh after making change
+ * See parser.js in this directory for generated output
+ * ===========================================================================
+ *
+ * SmartTextInput grammar — superset of the method chain grammar.
+ *
+ * Imports the method chain parser's Chain rule and adds:
+ *   - {{...}} Handlebars delimiter handling
+ *   - ${...} Code delimiter handling
+ *   - Top-level text handling (catch-all Text rule)
+ *
+ * Two start rules:
+ *   - Root       (default) — for interpolation mode: value may contain {{...}}, ${...}, and text
+ *   - ChainRoot             — for method-chain mode: the entire value is one Chain expression
+ */
+
+import Chain from "../method-chain/parser.js"
+
+{{
+  function mkNode(type, start, end, children) {
+    return { type, start, end, children: children || [] };
+  }
+  function mkError(start, end, kind, extra) {
+    return { type: 'error', start, end, ...(kind ? { kind } : {}), ...(extra || {}) };
+  }
+  function hasErrors(node) {
+    if (!node || typeof node !== 'object') return false;
+    if (node.type === 'error') return true;
+    const children = node.children || [];
+    return children.some(hasErrors);
+  }
+}}
+
+// Default start rule: interpolation mode.
+Root
+  = children:TopLevel* {
+      const node = mkNode('root', 0, input.length, children);
+      if (options.strict === true && hasErrors(node)) { error('Invalid expression'); }
+      return node;
+    }
+
+// Method-chain start rule: the entire value is a Chain expression.
+// Chain (with strict:false option) returns an AST with error nodes for invalid input.
+ChainRoot
+  = chain:Chain {
+      return mkNode('root', 0, input.length, [chain]);
+    }
+
+TopLevel
+  = &{ return !!options.allowHandlebars } node:Handlebars { return node; }
+  / &{ return !!options.allowCode } node:Code { return node; }
+  / Text
+
+// ---- Handlebars: {{chain}} ----
+// Uses imported Chain (full workflow syntax with functions/params) inside delimiters.
+// Chain with strict:false returns error-node ASTs instead of throwing, so both
+// the closed and unclosed forms just need two alternatives.
+
+Handlebars
+  = "{{" chain:Chain "}}" {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('handlebars', s, e, [
+        mkNode('hb_open', s, s + 2),
+        chain,
+        mkNode('hb_close', e - 2, e),
+      ]);
+    }
+  / "{{" chain:Chain {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('handlebars', s, e, [
+        mkNode('hb_open', s, s + 2),
+        chain,
+        mkError(e, e, 'unclosedHandlebars'),
+      ]);
+    }
+  / "{{" "}}" {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('handlebars', s, e, [
+        mkNode('hb_open', s, s + 2),
+        mkError(s + 2, s + 2, 'emptyHandlebars'),
+        mkNode('hb_close', e - 2, e),
+      ]);
+    }
+  / "{{" {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('handlebars', s, e, [
+        mkNode('hb_open', s, s + 2),
+        mkError(e, e, 'unclosedHandlebars'),
+      ]);
+    }
+
+// ---- Code: ${...} ----
+// Treats content inside ${...} as opaque text rather than a chain expression.
+// The inner content is emitted as a single code node regardless of what is typed.
+// Closed form (with matching close brace) and open-ended form (unclosed) are both handled.
+
+Code
+  = "${" CodeContent "}" {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('code', s, e, [
+        mkNode('code_open', s, s + 2),
+        { type: 'code', start: s + 2, end: e - 1 },
+        mkNode('code_close', e - 1, e),
+      ]);
+    }
+  / "${" CodeContent {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('code', s, e, [
+        mkNode('code_open', s, s + 2),
+        { type: 'code', start: s + 2, end: e },
+      ]);
+    }
+
+// Content inside ${...}: any characters that are not a new delimiter start or the closing brace.
+CodeContent = (!("${" / "}" / "{{") .)*
+
+// ---- Primitives ----
+
+DotNode
+  = "." {
+      return { type: 'dot', start: location().start.offset, end: location().end.offset };
+    }
+
+// Optional whitespace (spaces and tabs only).
+_ = [ \t]*
+
+// Plain text: any run of characters. Stops at {{...}} or ${...} only when the
+// corresponding expression type is enabled (allowHandlebars / allowCode options).
+Text
+  = chars:TextChar+ {
+      const s = location().start.offset;
+      const e = location().end.offset;
+      return mkNode('text', s, e);
+    }
+
+// A single character that is not the start of an enabled expression delimiter.
+TextChar
+  = !(EnabledHandlebarsStart / EnabledCodeStart) .
+
+// Matches "{{" only when handlebars expressions are enabled.
+EnabledHandlebarsStart
+  = &{ return !!options.allowHandlebars } "{{"
+
+// Matches "${" only when code expressions are enabled.
+EnabledCodeStart
+  = &{ return !!options.allowCode } "${"

package/dist/components/SmartTextInput/parser/smart-text/parser.d.mts

@@ -0,0 +1,17 @@
+import type { ASTNode } from './types';
+
+export type ParseOptions = {
+  startRule?: 'Root' | 'ChainRoot';
+  /** Whether to parse {{...}} as handlebars expressions. Defaults to false. */
+  allowHandlebars?: boolean;
+  /** Whether to parse ${...} as code expressions. Defaults to false. */
+  allowCode?: boolean;
+  /**
+   * When false, Chain returns an AST with error nodes instead of throwing.
+   * Must be false for SmartTextInput (error-recovering) usage.
+   * Defaults to strict mode (undefined treated as strict) for workflow callers.
+   */
+  strict?: boolean;
+};
+
+export function parse(input: string, options?: ParseOptions): ASTNode;