rooklang 0.4.1 → 0.4.2

package/dist/codegen/analysis.d.ts

@@ -10,6 +10,12 @@ export declare function containsElement(node: ast.Node): boolean;
 export declare function hasOptionalLink(node: ast.Expression): boolean;
 export declare function endsWithJump(statements: readonly ast.Statement[]): boolean;
 export declare function startsWithObjectLiteral(node: ast.Expression): boolean;
+/**
+ * Function literals that an expression gives as its value, not to a call: `() => count++`, the
+ * branches of `ok ? save : () => {}`, the fields of `{ onSave: () => {...} }`. They run later, when
+ * whoever gets them calls them; a callback given to a call, as to `items.map`, may run right away.
+ */
+export declare function functionValues(node: ast.Expression): ast.Expression[];
 /** The variable at the start of `a.b.c`, or `null`. */
 export declare function rootName(node: ast.Expression): string | null;
 /** Literals, which can be put into inlined code as they are. */

package/dist/codegen/analysis.js

@@ -104,6 +104,30 @@ export function startsWithObjectLiteral(node) {
             return false;
     }
 }
+/**
+ * Function literals that an expression gives as its value, not to a call: `() => count++`, the
+ * branches of `ok ? save : () => {}`, the fields of `{ onSave: () => {...} }`. They run later, when
+ * whoever gets them calls them; a callback given to a call, as to `items.map`, may run right away.
+ */
+export function functionValues(node) {
+    switch (node.kind) {
+        case 'ArrowFunction':
+        case 'FuncExpression':
+            return [node];
+        case 'ConditionalExpression':
+            return [...functionValues(node.consequent), ...functionValues(node.alternate)];
+        case 'BinaryExpression':
+            return node.operator === '??' || node.operator === '||' || node.operator === '&&'
+                ? [...functionValues(node.left), ...functionValues(node.right)]
+                : [];
+        case 'ArrayLiteral':
+            return node.elements.flatMap((element) => element.kind === 'SpreadElement' ? [] : functionValues(element));
+        case 'ObjectLiteral':
+            return node.properties.flatMap((property) => property.kind === 'Property' ? functionValues(property.value) : []);
+        default:
+            return [];
+    }
+}
 /** The variable at the start of `a.b.c`, or `null`. */
 export function rootName(node) {
     if (node.kind === 'Identifier')

package/dist/codegen/updates.d.ts

@@ -19,6 +19,8 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     protected rendering: number;
+    /** Functions that live markup gives as values: they run later, not while it is rendered. */
+    private readonly later;
     /**
      * After a statement that changes state of the module, the updates of the components that read
      * it; code that renders markup changes none, as with the state of a component.
@@ -41,9 +43,12 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
     protected liveFunction(node: ast.Expression): string;
     /**
      * An expression that is evaluated again on updates: elements inside it are created in place,
-     * so that each evaluation creates new ones.
+     * so that each evaluation creates new ones. A function that it gives as a value, as to a property
+     * `onAdd={() => count++}`, runs later, so what it changes updates the markup as it does in the
+     * value the markup was created with.
      */
     protected liveExpression(node: ast.Expression, precedence?: number): string;
+    protected expression(node: ast.Expression, minPrecedence: number, forceParens?: boolean): string;
 }
 /**
  * Replaces the markers of a component's sources: by the call of the update function, by the only

package/dist/codegen/updates.js

@@ -1,7 +1,7 @@
 import { widenLiterals } from "../checker/types.js";
 import { updatesOf } from "./reactive.js";
 import { StatementEmitter } from "./statements.js";
-import { startsWithObjectLiteral } from "./analysis.js";
+import { functionValues, startsWithObjectLiteral } from "./analysis.js";
 import { sharedWrites } from "./shared.js";
 import { ARROW } from "./syntax.js";
 /**
@@ -21,6 +21,8 @@ export class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     rendering = 0;
+    /** Functions that live markup gives as values: they run later, not while it is rendered. */
+    later = new WeakSet();
     /**
      * After a statement that changes state of the module, the updates of the components that read
      * it; code that renders markup changes none, as with the state of a component.
@@ -157,11 +159,20 @@ export class UpdateEmitter extends StatementEmitter {
     }
     /**
      * An expression that is evaluated again on updates: elements inside it are created in place,
-     * so that each evaluation creates new ones.
+     * so that each evaluation creates new ones. A function that it gives as a value, as to a property
+     * `onAdd={() => count++}`, runs later, so what it changes updates the markup as it does in the
+     * value the markup was created with.
      */
     liveExpression(node, precedence = ARROW) {
+        for (const value of functionValues(node))
+            this.later.add(value);
         return this.withRendering(this.rendering + 1, () => this.withHoisting(false, () => this.expression(node, precedence)));
     }
+    expression(node, minPrecedence, forceParens = false) {
+        return this.later.has(node)
+            ? this.withRendering(0, () => super.expression(node, minPrecedence, forceParens))
+            : super.expression(node, minPrecedence, forceParens);
+    }
 }
 /**
  * Replaces the markers of a component's sources: by the call of the update function, by the only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rooklang",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "A language with JavaScript semantics, Go-style syntax, goroutines on real threads and static types that compiles to readable JavaScript",
   "keywords": [
     "rooklang",