@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/analyze/reactive-expr.cjs

@@ -1 +1,38 @@
-"use strict";var t=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var s=(e,r)=>{for(var p in r)t(e,p,{get:r[p],enumerable:!0})},l=(e,r,p,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of i(r))!u.call(e,n)&&n!==p&&t(e,n,{get:()=>r[n],enumerable:!(a=c(r,n))||a.enumerable});return e};var d=e=>l(t({},"__esModule",{value:!0}),e);var E={};s(E,{isReactiveShape:()=>o});module.exports=d(E);var m="children";function o(e){switch(e.kind){case"call":return!0;case"member":return e.property!==m;case"compound":return e.parts.some(o);case"opaque":return!1}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/reactive-expr.ts
+var reactive_expr_exports = {};
+__export(reactive_expr_exports, {
+  isReactiveShape: () => isReactiveShape
+});
+module.exports = __toCommonJS(reactive_expr_exports);
+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;
+  }
+}

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.d.ts

@@ -2,12 +2,12 @@
  * 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
+ * `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. */
+/** A call: `count()`, `t('key')`, `mergeRefs(a, b)`. Always reactive. */
 {
     kind: 'call';
 }
@@ -20,7 +20,7 @@ export type ExprShape =
     property: string | null;
 }
 /**
- * Anything built out of sub-expressions — conditionals, logical and binary
+ * 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
@@ -30,7 +30,7 @@ export type ExprShape =
     kind: 'compound';
     parts: ExprShape[];
 }
-/** Identifiers, literals, functions, JSX — passed through untouched. */
+/** Identifiers, literals, functions, JSX: passed through untouched. */
  | {
     kind: 'opaque';
 };

package/dist/analyze/reactive-expr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactive-expr.d.ts","sourceRoot":"","sources":["../../src/analyze/reactive-expr.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,SAAS;AACnB,0EAA0E;AACxE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB;;;GAGG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAC7C;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE;AAC1C,wEAAwE;GACtE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAavB,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAWzD"}
+{"version":3,"file":"reactive-expr.d.ts","sourceRoot":"","sources":["../../src/analyze/reactive-expr.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,SAAS;AACnB,yEAAyE;AACvE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB;;;GAGG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAC7C;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE;AAC1C,uEAAuE;GACrE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAavB,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAWzD"}

package/dist/analyze/reactive-expr.js

@@ -2,12 +2,12 @@
  * 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
+ * `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.
  */
 /**
- * `props.children` — and any `.children` access — is a stable subtree reference,
+ * `props.children`: and any `.children` access: is a stable subtree reference,
  * not a reactive value. Compiling it to a `() => props.children` thunk adds an
  * insert layer that fully unwraps the children's Suspense/memo into a static node,
  * severing the reactive binding: a nested lazy/Suspense that resolves later never

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
+};