@swell/apps-sdk 1.0.180 → 1.0.181

package/dist/index.mjs

@@ -5423,7 +5423,7 @@ function getBlog(swell, id, query) {
 
 // src/easyblocks/config.ts
 import JSON53 from "json5";
-import { reduce as reduce2 } from "lodash-es";
+import { reduce as reduce2, set } from "lodash-es";
 
 // src/compatibility/drops/template.ts
 import { Drop as Drop3 } from "liquidjs";
@@ -5759,86 +5759,76 @@ function prepareSectionId(id) {
 }
 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) {
+            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"] || "",
-            ...reduce2(
-              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}`,
-                    ...reduce2(
-                      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}`,
-            ...reduce2(
+            ...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;
@@ -6269,7 +6259,7 @@ import JSON56 from "json5";
 import { get as get2, each, find, reduce as reduce3, cloneDeep as cloneDeep4 } from "lodash-es";
 
 // src/compatibility/shopify.ts
-import { get, isObject as isObject4, merge } from "lodash-es";
+import { get, set as set2, isObject as isObject4, merge } from "lodash-es";
 
 // src/fonts.ts
 var fontMap = [
@@ -11558,16 +11548,16 @@ function ShopifyBlog(instance, blogCategory) {
     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,
@@ -11951,18 +11941,18 @@ function ShopifyCollection(instance, category) {
       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();
@@ -14312,26 +14302,32 @@ ${injects.join("\n")}</script>`;
     if (!isObject4(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 = get(editorLocaleConfig, keyPath);
+          const langObject = get(localeConfig, keyPath);
           return langObject?.[keyName] ?? key;
         }
         break;
@@ -14341,11 +14337,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
               )
             );
           }
@@ -14354,12 +14350,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
+                );
+                set2(result, `$locale.${locale}.${key}`, localeValue);
+              }
+            }
           }
           return result;
         }