leanweb 1.3.1 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "leanweb",
-   "version": "1.3.1",
+   "version": "1.3.2",
    "description": "Builds framework agnostic web components.",
    "bin": {
       "leanweb": "leanweb.js",

package/templates/lib/lw-element.js

@@ -200,6 +200,8 @@ export default class LWElement extends HTMLElement {
       });
    }
 
+   // properties:
+   // lw_input_bound: boolean
    _bindInputs(inputNode) {
       if (inputNode['lw_input_bound']) {
          return;
@@ -237,14 +239,15 @@ export default class LWElement extends HTMLElement {
                   const context = this._getNodeContext(eventNode);
                   const eventContext = { '$event': event, '$node': eventNode };
                   const parsed = parser.evaluate(interpolation.ast, [eventContext, ...context], interpolation.loc);
-
-                  const promises = parsed.filter(p => typeof p?.then === 'function');
+                  const promises = parsed.filter(p => typeof p?.then === 'function' && typeof p?.finally === 'function');
                   if (parsed.length > promises.length) {
                      me.update();
                   }
-                  if (promises.length > 0) {
-                     Promise.allSettled(promises).then(_ => me.update());
-                  }
+                  promises.forEach(p => {
+                     p?.finally(() => {
+                        me.update();
+                     });
+                  });
                }).bind(me));
             });
          }

package/templates/lib/lw-expr-parser.js

@@ -24,6 +24,25 @@ const binaryOperations = {
    //  '|>': (a, b) => a |> b,
 };
 
+const assignmentOperations = {
+   '=': (c, a, b) => { c[a] = b; },
+   '+=': (c, a, b) => { c[a] += b; },
+   '-=': (c, a, b) => { c[a] -= b; },
+   '*=': (c, a, b) => { c[a] *= b; },
+   '/=': (c, a, b) => { c[a] /= b; },
+   '%=': (c, a, b) => { c[a] %= b; },
+   '**=': (c, a, b) => { c[a] **= b; },
+   '&&=': (c, a, b) => { c[a] &&= b; },
+   '??=': (c, a, b) => { c[a] ??= b; },
+   '||=': (c, a, b) => { c[a] ||= b; },
+   '>>=': (c, a, b) => { c[a] >>= b; },
+   '>>>=': (c, a, b) => { c[a] >>>= b; },
+   '<<=': (c, a, b) => { c[a] <<= b; },
+   '&=': (c, a, b) => { c[a] &= b; },
+   '|=': (c, a, b) => { c[a] |= b; },
+   '^=': (c, a, b) => { c[a] ^= b; },
+};
+
 const logicalOperators = {
    '||': (a, b) => a || b,
    '&&': (a, b) => a && b,
@@ -43,9 +62,9 @@ const unaryOperators = {
 
 const updateOperators = (operator, prefix) => {
    if (operator === '++') {
-      return prefix ? a => ++a : a => a++;
+      return (c, a) => prefix ? ++c[a] : c[a]++;
    } else if (operator === '--') {
-      return prefix ? a => --a : a => a--;
+      return (c, a) => prefix ? --c[a] : c[a]--;
    }
 };
 
@@ -75,9 +94,16 @@ const nodeHandlers = {
 
    'ExpressionStatement': (node, context) => evalNode(node.expression, context),
    'BinaryExpression': (node, context) => binaryOperations[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
+   'AssignmentExpression': (node, context) => {
+      const immediateCtx = immediateContext(node.left, context);
+      assignmentOperations[node.operator](immediateCtx, node.left.name, evalNode(node.right, context));
+   },
    'LogicalExpression': (node, context) => logicalOperators[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
    'UnaryExpression': (node, context) => unaryOperators[node.operator](evalNode(node.argument, context)),
-   'UpdateExpression': (node, context) => updateOperators(node.operator, node.prefix)(evalNode(node.argument, context)),
+   'UpdateExpression': (node, context) => {
+      const immediateCtx = immediateContext(node.argument, context);
+      updateOperators(node.operator, node.prefix)(immediateCtx, node.argument.name, evalNode(node.argument, context));
+   },
    'ConditionalExpression': (node, context) => {
       const test = evalNode(node.test, context);
       const consequent = evalNode(node.consequent, context);
@@ -144,6 +170,14 @@ const nodeHandlers = {
    'DirectiveLiteral': (node, context) => node.value,
 };
 
+const immediateContext = (node, context) => {
+   if (Array.isArray(context)) {
+      return context.find(contextObj => node.name in contextObj);
+   } else if (typeof context === 'object') {
+      return context;
+   }
+}
+
 const evalNode = (node, context) => nodeHandlers[node.type](node, context);
 
 const evaluate = (ast, context = {}, loc = {}) => {