@farm.js/react 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/vite.mjs

@@ -851,11 +851,11 @@ function analyzeKeyedRowsContainer(container, statesByValue, safeGlobals, listNa
   if (children.length !== 1) return void 0;
   return analyzeKeyedRowChild(children[0], statesByValue, safeGlobals, listNames);
 }
-function isStaticKeyedRangeSibling(element, statesByValue, safeGlobals) {
+function isStaticRangeSibling(element, statesByValue, safeGlobals) {
   for (const child of meaningfulJsxChildren(element)) {
     if (types.isJSXFragment(child)) return false;
     if (types.isJSXElement(child)) {
-      if (!isHostElement(child) || !isStaticKeyedRangeSibling(child, statesByValue, safeGlobals)) {
+      if (!isHostElement(child) || !isStaticRangeSibling(child, statesByValue, safeGlobals)) {
         return false;
       }
       continue;
@@ -896,7 +896,7 @@ function analyzeKeyedRangesContainer(container, statesByValue, safeGlobals, list
       continue;
     }
     if (!types.isJSXElement(child) || !isHostElement(child)) return void 0;
-    if (!isStaticKeyedRangeSibling(child, statesByValue, safeGlobals)) return void 0;
+    if (!isStaticRangeSibling(child, statesByValue, safeGlobals)) return void 0;
     staticBefore += 1;
   }
   if (ranges.length === 0) return void 0;
@@ -1048,6 +1048,60 @@ function analyzeHostConditionalContainer(container, statesByValue, safeGlobals)
     falsyBindings: falsyAnalysis.bindings || []
   };
 }
+function analyzeConditionalRangesContainer(container, statesByValue, safeGlobals, allowSingleRange = false) {
+  const containerName = container.openingElement.name;
+  if (!types.isJSXIdentifier(containerName) || !/^[a-z]/.test(containerName.name) || containerName.name === "svg" || container.openingElement.attributes.some(
+    (attribute) => types.isJSXSpreadAttribute(attribute) || types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name) && (attribute.name.name === "ref" || attribute.name.name === "dangerouslySetInnerHTML")
+  )) {
+    return void 0;
+  }
+  const children = meaningfulJsxChildren(container);
+  if (children.length < (allowSingleRange ? 1 : 2)) return void 0;
+  const ranges = [];
+  const dependencies = /* @__PURE__ */ new Set();
+  let staticBefore = 0;
+  for (const child of children) {
+    if (types.isJSXExpressionContainer(child) && !types.isJSXEmptyExpression(child.expression)) {
+      const shape = conditionalBlockShape(child.expression);
+      if (shape && !validateDerivedExpression(shape.test, safeGlobals)) {
+        const truthyAnalysis = shape.truthy ? analyzeHostConditionalTree(shape.truthy, safeGlobals) : { bindings: [] };
+        const falsyAnalysis = shape.falsy ? analyzeHostConditionalTree(shape.falsy, safeGlobals) : { bindings: [] };
+        if (truthyAnalysis.reason || falsyAnalysis.reason) return void 0;
+        const rangeDependencies = new Set(collectStateDependencies(shape.test, statesByValue));
+        for (const binding of [
+          ...truthyAnalysis.bindings || [],
+          ...falsyAnalysis.bindings || []
+        ]) {
+          for (const dependency of collectStateDependencies(binding.value, statesByValue)) {
+            rangeDependencies.add(dependency);
+          }
+        }
+        for (const dependency of rangeDependencies) dependencies.add(dependency);
+        ranges.push({
+          before: staticBefore,
+          source: child.expression,
+          test: cloneExpression(shape.test),
+          logical: shape.logical,
+          truthy: shape.truthy,
+          falsy: shape.falsy,
+          truthyBindings: truthyAnalysis.bindings || [],
+          falsyBindings: falsyAnalysis.bindings || []
+        });
+        staticBefore = 0;
+        continue;
+      }
+    }
+    if (!types.isJSXElement(child) || !isHostElement(child)) return void 0;
+    if (!isStaticRangeSibling(child, statesByValue, safeGlobals)) return void 0;
+    staticBefore += 1;
+  }
+  if (ranges.length === 0) return void 0;
+  return {
+    ranges,
+    trailing: staticBefore,
+    dependencies: [...dependencies].sort((left, right) => left - right)
+  };
+}
 function keyedListBoundary(blockRuntime, plan, source) {
   const name = types.jsxMemberExpression(
     types.jsxIdentifier(blockRuntime.name),
@@ -1510,6 +1564,67 @@ function hostConditionalBoundary(blockRuntime, plan) {
   }
   return types.jsxElement(types.jsxOpeningElement(name, attributes, true), null, [], true);
 }
+function conditionalRangeObject(range) {
+  const properties = [
+    types.objectProperty(types.identifier("before"), types.numericLiteral(range.before)),
+    types.objectProperty(
+      types.identifier("test"),
+      types.arrowFunctionExpression([], cloneExpression(range.test))
+    )
+  ];
+  if (range.logical) {
+    properties.push(types.objectProperty(types.identifier("logical"), types.booleanLiteral(true)));
+  }
+  if (range.truthy) {
+    properties.push(
+      types.objectProperty(
+        types.identifier("truthy"),
+        hostConditionalBranchObject(range.truthy, range.truthyBindings)
+      )
+    );
+  }
+  if (range.falsy) {
+    properties.push(
+      types.objectProperty(
+        types.identifier("falsy"),
+        hostConditionalBranchObject(range.falsy, range.falsyBindings)
+      )
+    );
+  }
+  return types.objectExpression(properties);
+}
+function conditionalRangesBoundary(blockRuntime, plan) {
+  const name = types.jsxMemberExpression(
+    types.jsxIdentifier(blockRuntime.name),
+    types.jsxIdentifier("ConditionalRanges")
+  );
+  const source = types.cloneNode(plan.source, true);
+  const rootRefIndex = source.openingElement.attributes.findIndex(
+    (attribute) => types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name) && attribute.name.name === "ref"
+  );
+  const rootRef = rootRefIndex >= 0 ? source.openingElement.attributes.splice(rootRefIndex, 1)[0] : void 0;
+  const attributes = [
+    types.jsxAttribute(types.jsxIdentifier("id"), types.jsxExpressionContainer(types.numericLiteral(plan.id))),
+    types.jsxAttribute(
+      types.jsxIdentifier("render"),
+      types.jsxExpressionContainer(types.arrowFunctionExpression([], source))
+    ),
+    types.jsxAttribute(
+      types.jsxIdentifier("ranges"),
+      types.jsxExpressionContainer(
+        types.arrayExpression(plan.ranges.map((range) => conditionalRangeObject(range)))
+      )
+    ),
+    types.jsxAttribute(
+      types.jsxIdentifier("trailing"),
+      types.jsxExpressionContainer(types.numericLiteral(plan.trailing))
+    )
+  ];
+  if (rootRef?.value) {
+    attributes.push(types.jsxAttribute(types.jsxIdentifier("rootRef"), types.cloneNode(rootRef.value, true)));
+  }
+  return types.jsxElement(types.jsxOpeningElement(name, attributes, true), null, [], true);
+}
 function analyzeComponentIslandElement(element, statesByValue, safeGlobals, allowedComponentNames) {
   const name = element.openingElement.name;
   if (!types.isJSXIdentifier(name) || !isComponentName(name.name)) {
@@ -1692,6 +1807,22 @@ function analyzeComposableBlocks(root, statesByValue, safeGlobals, listNames, al
             }
             continue;
           }
+          const conditionalRanges = insideConditional ? void 0 : analyzeConditionalRangesContainer(child, statesByValue, safeGlobals);
+          if (conditionalRanges) {
+            plans.push({
+              kind: "conditional-ranges",
+              id: nextId++,
+              parent,
+              dependencies: conditionalRanges.dependencies,
+              source: child,
+              ranges: conditionalRanges.ranges,
+              trailing: conditionalRanges.trailing
+            });
+            for (const range of conditionalRanges.ranges) {
+              conditionalExpressions.add(range.source);
+            }
+            continue;
+          }
           const hostConditional = analyzeHostConditionalContainer(
             child,
             statesByValue,
@@ -1846,6 +1977,32 @@ function analyzeComposableBlocks(root, statesByValue, safeGlobals, listNames, al
       keyedExpressions
     };
   }
+  const rootConditionalRanges = analyzeConditionalRangesContainer(
+    root,
+    statesByValue,
+    safeGlobals,
+    true
+  );
+  if (rootConditionalRanges) {
+    plans.push({
+      kind: "conditional-ranges",
+      id: nextId++,
+      dependencies: rootConditionalRanges.dependencies,
+      source: root,
+      ranges: rootConditionalRanges.ranges,
+      trailing: rootConditionalRanges.trailing
+    });
+    for (const range of rootConditionalRanges.ranges) {
+      conditionalExpressions.add(range.source);
+    }
+    return {
+      plans,
+      componentElements,
+      conditionalExpressions,
+      ownedElements,
+      keyedExpressions
+    };
+  }
   const result = visitHost(root, void 0, false);
   if (result.reason) return { reason: result.reason };
   return {
@@ -1886,6 +2043,9 @@ function lowerComposableBlocks(root, plans, blockRuntime, listNames) {
   if (rootPlan?.kind === "keyed-ranges") {
     return keyedRangesBoundary(blockRuntime, rootPlan);
   }
+  if (rootPlan?.kind === "conditional-ranges") {
+    return conditionalRangesBoundary(blockRuntime, rootPlan);
+  }
   const visit = (element) => {
     element.children = element.children.map((child) => {
       if (types.isJSXElement(child)) {
@@ -1899,6 +2059,9 @@ function lowerComposableBlocks(root, plans, blockRuntime, listNames) {
         if (plan2?.kind === "keyed-ranges") {
           return keyedRangesBoundary(blockRuntime, plan2);
         }
+        if (plan2?.kind === "conditional-ranges") {
+          return conditionalRangesBoundary(blockRuntime, plan2);
+        }
         if (plan2?.kind === "component") {
           return componentIslandBoundary(blockRuntime, plan2, child);
         }