fix(loadable-components): honor final ssr override order (#592)

Author: kdy1

packages/loadable-components/src/lib.rs

@@ -138,24 +138,40 @@ where
             _ => return false,
         };
 
-        obj.props.iter().any(|prop| match prop {
-            PropOrSpread::Prop(prop) => match prop.as_ref() {
-                Prop::KeyValue(kv) => {
-                    let is_ssr_key = match &kv.key {
-                        PropName::Ident(i) => &*i.sym == "ssr",
-                        PropName::Str(s) => s.value == "ssr",
-                        _ => false,
-                    };
-                    is_ssr_key
-                        && matches!(
+        // Object literals are order-sensitive. Walk from right to left to find
+        // the last effective `ssr` assignment. We can only skip when it is
+        // definitely `false`.
+        for prop in obj.props.iter().rev() {
+            match prop {
+                PropOrSpread::Prop(prop) => match prop.as_ref() {
+                    Prop::KeyValue(kv) => {
+                        let is_ssr_key = match &kv.key {
+                            PropName::Ident(i) => &*i.sym == "ssr",
+                            PropName::Str(s) => s.value == "ssr",
+                            _ => false,
+                        };
+
+                        if !is_ssr_key {
+                            continue;
+                        }
+
+                        return matches!(
                             kv.value.as_ref(),
                             Expr::Lit(Lit::Bool(Bool { value: false, .. }))
-                        )
-                }
-                _ => false,
-            },
-            _ => false,
-        })
+                        );
+                    }
+                    Prop::Shorthand(ident) if &*ident.sym == "ssr" => {
+                        // Dynamic shorthand value: cannot guarantee false.
+                        return false;
+                    }
+                    _ => {}
+                },
+                // A spread may provide/override `ssr` dynamically.
+                PropOrSpread::Spread(_) => return false,
+            }
+        }
+
+        false
     }
 
     fn transform_import_expr(&mut self, call: &mut CallExpr) {

packages/loadable-components/tests/fixture/simple import/should transform when ssr false is overridden/input.js

@@ -0,0 +1,5 @@
+import loadable from "@loadable/component";
+
+const opts = { ssr: true };
+
+loadable(() => import("./OtherComponent"), { ssr: false, ...opts });

packages/loadable-components/tests/fixture/simple import/should transform when ssr false is overridden/output.js

@@ -0,0 +1,45 @@
+import loadable from "@loadable/component";
+const opts = {
+    ssr: true
+};
+loadable({
+    resolved: {},
+    chunkName () {
+        return "OtherComponent";
+    },
+    isReady (props) {
+        const key = this.resolve(props);
+        if (this.resolved[key] !== true) {
+            return false;
+        }
+        if (typeof __webpack_modules__ !== 'undefined') {
+            return !!__webpack_modules__[key];
+        }
+        return false;
+    },
+    importAsync: ()=>import(/*webpackChunkName: "OtherComponent"*/ "./OtherComponent"),
+    requireAsync (props) {
+        const key = this.resolve(props);
+        this.resolved[key] = false;
+        return this.importAsync(props).then((resolved)=>{
+            this.resolved[key] = true;
+            return resolved;
+        });
+    },
+    requireSync (props) {
+        const id = this.resolve(props);
+        if (typeof __webpack_require__ !== 'undefined') {
+            return __webpack_require__(id);
+        }
+        return eval('module.require')(id);
+    },
+    resolve () {
+        if (require.resolveWeak) {
+            return require.resolveWeak("./OtherComponent");
+        }
+        return eval('require.resolve')("./OtherComponent");
+    }
+}, {
+    ssr: false,
+    ...opts
+});