@swell/apps-sdk 1.0.180 → 1.0.182

package/dist/index.js

@@ -915,7 +915,10 @@
       }
       return this._resolve().then(() => this.makeIterator());
     }
-    makeIterator() {
+    async makeIterator() {
+      if (isLikePromise(this.results)) {
+        await this.results;
+      }
       return (this.results || []).values();
     }
     _clone(newProps) {
@@ -3667,11 +3670,11 @@
     );
   }
   function getCountryCodeFromLocale(locale) {
-    const split = locale.split(/-|_/);
-    const country = split.pop()?.toUpperCase();
-    const lang = split.join("-");
-    const code = country ? country : LANG_TO_COUNTRY_CODES[lang] || "";
-    return code.toLowerCase();
+    const [lang, country] = locale.split(/-|_/);
+    if (country) {
+      return country.toLowerCase();
+    }
+    return (LANG_TO_COUNTRY_CODES[lang] || "").toLowerCase();
   }
   function getCountryByCurrency(currencyCode) {
     if (currencyCode in CURRENCY_COUNTRIES) {
@@ -5786,86 +5789,76 @@ ${formattedMessage}`;
   }
   function getAllSectionComponentTemplates(allSections) {
     const list = [];
+    const processFields = (fields, settings = {}) => {
+      const result = {};
+      for (const field of fields) {
+        if (!field?.id) {
+          continue;
+        }
+        const { id: fieldId, $locale } = field;
+        result[fieldId] = schemaToEasyblocksValue(
+          fields,
+          fieldId,
+          settings[fieldId]
+        );
+        if ($locale) {
+          for (const [locale, localeValues] of Object.entries($locale)) {
+            const defaultValue = localeValues?.default;
+            if (defaultValue) {
+              (0, import_lodash_es4.set)(result, `$locale.${locale}.${fieldId}`, defaultValue);
+            }
+          }
+        }
+      }
+      return result;
+    };
     for (const section of allSections) {
       if (section.presets) {
-        list.push(
-          ...section.presets.map((preset, index) => ({
+        for (let index = 0; index < section.presets.length; index++) {
+          const preset = section.presets[index];
+          const entry = {
+            _id: `${section.id}__preset_${index}`,
+            _component: section.id,
+            custom_css: preset.settings?.["custom_css"] || "",
+            ...processFields(section.fields, preset.settings),
+            // Process blocks inside the preset
+            Blocks: (preset.blocks || []).map((block) => {
+              const blockSchema = section.blocks?.find(
+                ({ type }) => type === block.type
+              );
+              if (!blockSchema) {
+                return null;
+              }
+              return {
+                _id: `Block__${section.id}__${block.type}__preset_${index}`,
+                _component: `Block__${section.id}__${block.type}`,
+                ...processFields(blockSchema.fields, block.settings)
+              };
+            }).filter(Boolean)
+          };
+          list.push({
             id: `${section.id}__preset_${index}`,
-            entry: {
-              _id: `${section.id}__preset_${index}`,
-              _component: section.id,
-              custom_css: preset.settings?.["custom_css"] || "",
-              ...(0, import_lodash_es4.reduce)(
-                section.fields,
-                (acc, field) => {
-                  if (field.id) {
-                    acc[field.id] = schemaToEasyblocksValue(
-                      section.fields,
-                      field.id,
-                      preset.settings?.[field.id]
-                    );
-                  }
-                  return acc;
-                },
-                {}
-              ),
-              Blocks: preset.blocks?.reduce(
-                (acc, block) => {
-                  const blockDef = section.blocks?.find(
-                    ({ type }) => type === block.type
-                  );
-                  if (blockDef) {
-                    acc.push({
-                      _id: `Block__${section.id}__${block.type}__preset_${index}`,
-                      _component: `Block__${section.id}__${block.type}`,
-                      ...(0, import_lodash_es4.reduce)(
-                        blockDef.fields,
-                        (acc2, blockField) => {
-                          if (blockField.id) {
-                            acc2[blockField.id] = schemaToEasyblocksValue(
-                              blockDef.fields,
-                              blockField.id,
-                              block.settings?.[blockField.id]
-                            );
-                          }
-                          return acc2;
-                        },
-                        {}
-                      )
-                    });
-                  }
-                  return acc;
-                },
-                []
-              )
-            }
-          }))
-        );
+            entry
+          });
+        }
       }
       if (section.blocks) {
-        list.push(
-          ...section.blocks.map((block) => ({
+        for (const block of section.blocks) {
+          list.push({
             id: `Block__${section.id}__${block.type}`,
             entry: {
               _id: `Block__${section.id}__${block.type}`,
               _component: `Block__${section.id}__${block.type}`,
-              ...(0, import_lodash_es4.reduce)(
+              ...processFields(
                 block.fields,
-                (acc, field) => {
-                  if (field.id) {
-                    acc[field.id] = schemaToEasyblocksValue(
-                      block.fields,
-                      field.id,
-                      field.default
-                    );
-                  }
+                block.fields.reduce((acc, f) => {
+                  if (f.id) acc[f.id] = f.default;
                   return acc;
-                },
-                {}
+                }, {})
               )
             }
-          }))
-        );
+          });
+        }
       }
     }
     return list;
@@ -10253,6 +10246,9 @@ ${formattedMessage}`;
 
   // src/compatibility/shopify-fonts.ts
   function shopifyFontToThemeFront(shopifyFontSetting) {
+    if (typeof shopifyFontSetting !== "string") {
+      return null;
+    }
     const pos = shopifyFontSetting.lastIndexOf("_");
     const familyId = shopifyFontSetting.substring(0, pos);
     const variantId = shopifyFontSetting.substring(pos + 1);
@@ -11585,16 +11581,16 @@ ${formattedMessage}`;
       if (!Array.isArray(blogs?.results)) {
         return [];
       }
-      const set = blogs.results.reduce(
-        (set2, blog) => {
+      const set3 = blogs.results.reduce(
+        (set4, blog) => {
           for (const tag of blog.tags || []) {
-            set2.add(tag);
+            set4.add(tag);
           }
-          return set2;
+          return set4;
         },
         /* @__PURE__ */ new Set()
       );
-      return Array.from(set.values());
+      return Array.from(set3.values());
     });
     return new ShopifyResource({
       all_tags: allTags,
@@ -11978,18 +11974,18 @@ ${formattedMessage}`;
         if (!resolved) {
           return [];
         }
-        const set = /* @__PURE__ */ new Set();
+        const set3 = /* @__PURE__ */ new Set();
         await Promise.all(
           resolved.results.map(async (product) => {
             const tags2 = await Promise.resolve().then(() => product.tags);
             if (Array.isArray(tags2)) {
               for (const tag of tags2) {
-                set.add(tag);
+                set3.add(tag);
               }
             }
           })
         );
-        return Array.from(set.values());
+        return Array.from(set3.values());
       }),
       all_types: defer(async () => {
         const products = await resolveProducts();
@@ -14339,26 +14335,32 @@ ${injects.join("\n")}<\/script>`;
       if (!(0, import_lodash_es7.isObject)(schema)) {
         return schema;
       }
-      const editorLocaleConfig = await this.getEditorLocaleConfig(
-        theme,
-        localeCode
-      );
+      const locales = await theme.swell.storefront.locale.list();
+      const localeCodes = /* @__PURE__ */ new Set([
+        localeCode,
+        ...locales.map((locale) => locale.code)
+      ]);
+      const localeConfigs = {};
+      for (const locale of localeCodes) {
+        localeConfigs[locale] = await this.getEditorLocaleConfig(theme, locale);
+      }
       return this.renderSchemaTranslationValue(
         theme,
         schema,
         localeCode,
-        editorLocaleConfig
+        localeConfigs
       );
     }
-    async renderSchemaTranslationValue(theme, schemaValue, localCode, editorLocaleConfig) {
+    renderSchemaTranslationValue(theme, schemaValue, localeCode, localeConfigs) {
       switch (typeof schemaValue) {
         case "string": {
           if (schemaValue.startsWith("t:")) {
+            const localeConfig = localeConfigs[localeCode];
             const key = schemaValue.slice(2);
             const keyParts = key?.split(".");
             const keyName = keyParts.pop() || "";
             const keyPath = keyParts.join(".");
-            const langObject = (0, import_lodash_es7.get)(editorLocaleConfig, keyPath);
+            const langObject = (0, import_lodash_es7.get)(localeConfig, keyPath);
             return langObject?.[keyName] ?? key;
           }
           break;
@@ -14368,11 +14370,11 @@ ${injects.join("\n")}<\/script>`;
             const result = [];
             for (const value of schemaValue) {
               result.push(
-                await this.renderSchemaTranslationValue(
+                this.renderSchemaTranslationValue(
                   theme,
                   value,
-                  localCode,
-                  editorLocaleConfig
+                  localeCode,
+                  localeConfigs
                 )
               );
             }
@@ -14381,12 +14383,26 @@ ${injects.join("\n")}<\/script>`;
           if (schemaValue !== null) {
             const result = { ...schemaValue };
             for (const [key, value] of Object.entries(schemaValue)) {
-              result[key] = await this.renderSchemaTranslationValue(
+              result[key] = this.renderSchemaTranslationValue(
                 theme,
                 value,
-                localCode,
-                editorLocaleConfig
+                localeCode,
+                localeConfigs
               );
+              if (typeof value === "string" && value.startsWith("t:")) {
+                for (const locale of Object.keys(localeConfigs)) {
+                  if (locale === localeCode) {
+                    continue;
+                  }
+                  const localeValue = this.renderSchemaTranslationValue(
+                    theme,
+                    value,
+                    locale,
+                    localeConfigs
+                  );
+                  (0, import_lodash_es7.set)(result, `$locale.${locale}.${key}`, localeValue);
+                }
+              }
             }
             return result;
           }
@@ -16088,19 +16104,12 @@ ${injects.join("\n")}<\/script>`;
   // src/liquid/filters/locale_flag.ts
   var import_country_flag_icons = __require("country-flag-icons");
   var flags = __toESM(__require("country-flag-icons/string/1x1"), 1);
-  function getCountryCode(localCode) {
-    if (localCode.includes("-")) {
-      return localCode.split("-")[1].toUpperCase();
-    } else {
-      return localCode.toUpperCase();
-    }
-  }
   function bind46(_liquidSwell) {
     return (localeCode) => {
       if (typeof localeCode !== "string") {
         return flags.US;
       }
-      const countryCode = getCountryCode(localeCode);
+      const countryCode = getCountryCodeFromLocale(localeCode).toUpperCase();
       return (0, import_country_flag_icons.hasFlag)(countryCode) ? flags[countryCode] : flags.US;
     };
   }
@@ -16308,7 +16317,7 @@ ${injects.join("\n")}<\/script>`;
   // src/liquid/filters/shopify/payment_button.ts
   function bind60(_liquidSwell) {
     return (form) => {
-      return null;
+      return `<button style="display: block; visibility: hidden;"></button>`;
     };
   }
 
@@ -18822,7 +18831,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     let blocks = settings.section.blocks?.filter(
       (block) => block.disabled !== true
     );
-    blocks = blocks?.map((block) => ({
+    blocks = blocks?.filter((block) => Boolean(block.type)).map((block) => ({
       ...block,
       ...getBlockAttributes(theme, block),
       settings: resolveThemeSettings(