@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/analyze/reactive-expr.d.cts

@@ -0,0 +1,38 @@
+/**
+ * Which expressions get wired reactively: `count()` re-runs on change, `count`
+ * does not, `props.children` is a subtree reference rather than a value.
+ *
+ * `ExprShape` is four cases and must not grow into a JavaScript AST — a front-end
+ * reports what the rule branches on, everything else collapses to `compound` or
+ * `opaque`. One rule, one place, whatever the parser.
+ */
+export type ExprShape = 
+/** A call — `count()`, `t('key')`, `mergeRefs(a, b)`. Always reactive. */
+{
+    kind: 'call';
+}
+/**
+ * A property access. `property` is the static name, or `null` when the access is
+ * computed or otherwise not a plain identifier (`obj[key]`, `obj[fn()]`).
+ */
+ | {
+    kind: 'member';
+    property: string | null;
+}
+/**
+ * Anything built out of sub-expressions — conditionals, logical and binary
+ * operators, template literals, object and array literals. Reactive when any
+ * part is, so `class={{ active: active() }}` reacts and `class={{ a: true }}`
+ * does not. The front-end decides which children count: a spread element or a
+ * computed key contributes nothing, because the compiler cannot see through it.
+ */
+ | {
+    kind: 'compound';
+    parts: ExprShape[];
+}
+/** Identifiers, literals, functions, JSX — passed through untouched. */
+ | {
+    kind: 'opaque';
+};
+/** Whether an expression of this shape must be wired reactively. */
+export declare function isReactiveShape(shape: ExprShape): boolean;

package/dist/analyze/reactive-expr.mjs

@@ -1 +1,17 @@
-var r="children";function n(e){switch(e.kind){case"call":return!0;case"member":return e.property!==r;case"compound":return e.parts.some(n);case"opaque":return!1}}export{n as isReactiveShape};
+// src/analyze/reactive-expr.ts
+var STABLE_MEMBER = "children";
+function isReactiveShape(shape) {
+  switch (shape.kind) {
+    case "call":
+      return true;
+    case "member":
+      return shape.property !== STABLE_MEMBER;
+    case "compound":
+      return shape.parts.some(isReactiveShape);
+    case "opaque":
+      return false;
+  }
+}
+export {
+  isReactiveShape
+};