@swell/apps-sdk 1.0.186 → 1.0.188

package/dist/index.mjs

@@ -3502,7 +3502,15 @@ function resolveSectionPresets(schema) {
       }, {}),
       ...preset.settings || void 0
     },
-    blocks: preset.blocks?.map((block) => {
+    blocks: resolveSectionBlockPresets(preset, schema)
+  }));
+}
+function resolveSectionBlockPresets(preset, schema) {
+  if (!preset.blocks) {
+    return;
+  }
+  if (Array.isArray(preset.blocks)) {
+    return preset.blocks.map((block) => {
       const blockDef = schema.blocks?.find((b) => b.type === block.type);
       return blockDef ? {
         ...block,
@@ -3516,8 +3524,9 @@ function resolveSectionPresets(schema) {
           ...block.settings || void 0
         }
       } : block;
-    })
-  }));
+    });
+  }
+  return Object.values(preset.blocks);
 }
 async function getLayoutSectionGroups(allSections, renderTemplateSchema) {
   const allSectionsList = Array.from(allSections.values());
@@ -3594,7 +3603,15 @@ async function getPageSections(sectionGroup, getSchema) {
     };
     const id = sectionGroup.id ? `page__${sectionGroup.id}__${key}` : schema.id;
     const blockOrder = Array.isArray(section.block_order) ? section.block_order : Object.keys(section.blocks || {});
-    const blocks = blockOrder.map((key2) => section.blocks?.[key2]).filter(Boolean);
+    const blocks = blockOrder.map((key2) => {
+      const block = section.blocks?.[key2];
+      if (block) {
+        return {
+          ...block,
+          id: `${schema.id}__${key2}`
+        };
+      }
+    }).filter(Boolean);
     const settings = {
       section: {
         id,
@@ -4816,12 +4833,17 @@ function transformSwellVariant(params, product, variant) {
 var SwellVariant = class extends SwellStorefrontRecord {
   product;
   constructor(swell, product, id, query) {
+    const params = swell.queryParams;
     super(swell, "products:variants", id, query, async function() {
       const variant = await this._swell.get(
-        "/products:variants/{id}",
-        { id: this._id }
+        "/products:variants/:last",
+        { $or: [{ id: this._id }, { sku: this._id }] }
+      );
+      return transformSwellVariant(
+        params,
+        product instanceof SwellStorefrontRecord ? await product.resolve() : product,
+        variant
       );
-      return variant ?? null;
     });
     this.product = product;
   }
@@ -5588,7 +5610,7 @@ function getAllSectionComponents(allSections) {
             // TODO: figure out how to make this work, doesn't work for collections normally
             defaultValue: section.presets?.reduce(
               (acc, preset, index) => {
-                if (!preset.blocks) {
+                if (!preset.blocks || !Array.isArray(preset.blocks)) {
                   return acc;
                 }
                 return preset.blocks.reduce(
@@ -5795,7 +5817,7 @@ function getAllSectionComponentTemplates(allSections) {
           custom_css: preset.settings?.["custom_css"] || "",
           ...processFields(section.fields, preset.settings),
           // Process blocks inside the preset
-          Blocks: (preset.blocks || []).map((block) => {
+          Blocks: (Array.isArray(preset.blocks) ? preset.blocks : []).map((block) => {
             const blockSchema = section.blocks?.find(
               ({ type }) => type === block.type
             );
@@ -11554,16 +11576,16 @@ function ShopifyBlog(instance, blogCategory) {
     if (!Array.isArray(blogs?.results)) {
       return [];
     }
-    const set3 = blogs.results.reduce(
-      (set4, blog) => {
+    const set4 = blogs.results.reduce(
+      (set5, blog) => {
         for (const tag of blog.tags || []) {
-          set4.add(tag);
+          set5.add(tag);
         }
-        return set4;
+        return set5;
       },
       /* @__PURE__ */ new Set()
     );
-    return Array.from(set3.values());
+    return Array.from(set4.values());
   });
   return new ShopifyResource({
     all_tags: allTags,
@@ -11947,18 +11969,18 @@ function ShopifyCollection(instance, category) {
       if (!resolved) {
         return [];
       }
-      const set3 = /* @__PURE__ */ new Set();
+      const set4 = /* @__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) {
-              set3.add(tag);
+              set4.add(tag);
             }
           }
         })
       );
-      return Array.from(set3.values());
+      return Array.from(set4.values());
     }),
     all_types: defer(async () => {
       const products = await resolveProducts();
@@ -14546,6 +14568,8 @@ ${injects.join("\n")}</script>`;
         return `templates/${this.getPageType(name)}`;
       case "sections":
         return `sections/${name}`;
+      case "blocks":
+        return `blocks/${name}`;
       default:
         throw new Error(`Theme file type not supported: ${type}`);
     }
@@ -14895,14 +14919,161 @@ function bind3(_liquidSwell) {
   };
 }
 
+// src/liquid/tags/content_for.ts
+import { Tag as Tag4 } from "liquidjs";
+import { assign } from "lodash-es";
+
+// src/liquid/hash.ts
+import { set as set3 } from "lodash-es";
+import { Hash, Tokenizer as Tokenizer2, evalToken as evalToken2 } from "liquidjs";
+
+// src/liquid/tokienizer.ts
+import { Tokenizer } from "liquidjs";
+
+// src/liquid/tokens/identifier-token.ts
+import { Token, TokenKind } from "liquidjs";
+var IdentifierToken = class extends Token {
+  constructor(input, begin, end, file) {
+    super(TokenKind.Word, input, begin, end, file);
+    this.input = input;
+    this.begin = begin;
+    this.end = end;
+    this.file = file;
+    this.content = this.getText();
+  }
+  content;
+};
+
+// src/liquid/tokienizer.ts
+var isNumber2 = (c) => c >= "0" && c <= "9";
+var isCharacter = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+var isWord = (c) => "_-?".includes(c) || isCharacter(c) || isNumber2(c);
+var TokenizerSwell = class extends Tokenizer {
+  readIdentifier() {
+    this.skipBlank();
+    const begin = this.p;
+    while (!this.end()) {
+      const char = this.peek();
+      if (isWord(char) || char === ".") {
+        this.p++;
+      } else {
+        break;
+      }
+    }
+    return new IdentifierToken(this.input, begin, this.p, this.file);
+  }
+};
+
+// src/liquid/hash.ts
+var HashSwell = class extends Hash {
+  constructor(input, jekyllStyle) {
+    super(input, jekyllStyle);
+    const tokenizer = input instanceof Tokenizer2 ? input : new TokenizerSwell(input, {});
+    for (const hash of tokenizer.readHashes(jekyllStyle)) {
+      this.hash[hash.name.content] = hash.value;
+    }
+  }
+  *render(ctx) {
+    const hash = {};
+    for (const key of Object.keys(this.hash)) {
+      const token = this.hash[key];
+      if (token !== void 0) {
+        const value = yield evalToken2(token, ctx);
+        set3(hash, key, value);
+      }
+    }
+    return hash;
+  }
+};
+
+// src/liquid/tags/content_for.ts
+function bind4(liquidSwell) {
+  return class ContentForTag extends Tag4 {
+    name;
+    hash;
+    constructor(token, remainTokens, liquid) {
+      super(token, remainTokens, liquid);
+      const tokenizer = token.tokenizer;
+      this.name = tokenizer.readValue()?.content;
+      this.hash = new HashSwell(tokenizer.remaining());
+    }
+    *render(ctx, emitter) {
+      const section = yield ctx._get(["section"]);
+      const block = yield ctx._get(["block"]);
+      const hash = yield this.hash.render(ctx);
+      const blocks = this.getBlocks(section, block, hash);
+      for (const block2 of blocks) {
+        if (!isObject2(block2) || typeof block2.type !== "string") {
+          continue;
+        }
+        const blockPath = yield liquidSwell.getThemeBlockPath(
+          block2.type
+        );
+        if (!blockPath) {
+          continue;
+        }
+        const childCtx = ctx.spawn();
+        const scope = childCtx.bottom();
+        assign(scope, { section });
+        assign(scope, { block: block2 });
+        assign(scope, hash);
+        const templates = yield this.liquid._parseFile(
+          blockPath,
+          childCtx.sync
+        );
+        yield this.liquid.renderer.renderTemplates(
+          templates,
+          childCtx,
+          emitter
+        );
+      }
+    }
+    getBlocks(section, block, hash) {
+      const blockConfigs = this.getBlockConfigs(section, block);
+      if (!isObject2(hash) || !hash.type) {
+        return blockConfigs;
+      }
+      const blockConfig = blockConfigs.find(
+        (blockConfig2) => isObject2(blockConfig2) && blockConfig2.type === hash.type
+      );
+      return blockConfig ? [blockConfig] : [];
+    }
+    getBlockConfigs(section, block) {
+      if (isObject2(block) && block.blocks) {
+        return Object.values(block.blocks);
+      }
+      if (isObject2(section) && Array.isArray(section.blocks)) {
+        return section.blocks;
+      }
+      return [];
+    }
+  };
+}
+
+// src/liquid/tags/doc.ts
+import { Tag as Tag5 } from "liquidjs";
+function bind5() {
+  return class DocTag extends Tag5 {
+    constructor(token, remainTokens, liquid, parser) {
+      super(token, remainTokens, liquid);
+      const stream = parser.parseStream(remainTokens).on("tag:enddoc", () => {
+        stream.stop();
+      });
+      stream.start();
+    }
+    render() {
+    }
+  };
+}
+
 // src/liquid/tags/for.ts
-import { evalToken as evalToken2, ForTag as LiquidForTag } from "liquidjs";
+import { evalToken as evalToken3, ForTag as LiquidForTag } from "liquidjs";
 var MODIFIERS = Object.freeze(["offset", "limit", "reversed"]);
-function bind4(_liquidSwell) {
+function bind6(_liquidSwell) {
   return class ForTag extends LiquidForTag {
     *render(ctx, emitter) {
       const r = this.liquid.renderer;
-      let collection = yield evalToken2(this.collection, ctx);
+      let collection = yield evalToken3(this.collection, ctx);
       collection = yield resolveEnumerable(collection);
       if (!collection.length) {
         yield r.renderTemplates(this.elseTemplates, ctx, emitter);
@@ -14969,10 +15140,10 @@ function limit(arr, count) {
 }
 
 // src/liquid/tags/form.ts
-import { Tag as Tag4, Hash, TypeGuards as TypeGuards2, evalToken as evalToken3 } from "liquidjs";
+import { Tag as Tag6, Hash as Hash3, TypeGuards as TypeGuards2, evalToken as evalToken4 } from "liquidjs";
 var IGNORED_SHOPIFY_FORMS = Object.freeze(["new_comment", "guest_login"]);
-function bind5(liquidSwell) {
-  return class FormTag extends Tag4 {
+function bind7(liquidSwell) {
+  return class FormTag extends Tag6 {
     formType;
     formConfig;
     templates;
@@ -14985,7 +15156,7 @@ function bind5(liquidSwell) {
       this.formConfig = liquidSwell.theme.getFormConfig(this.formType);
       this.arg = tokenizer.readValue();
       this.templates = [];
-      this.hash = new Hash(this.tokenizer.remaining());
+      this.hash = new Hash3(this.tokenizer.remaining());
       while (remainTokens.length > 0) {
         const token2 = remainTokens.shift();
         if (TypeGuards2.isTagToken(token2) && token2.name === "endform") {
@@ -15006,7 +15177,7 @@ function bind5(liquidSwell) {
         return;
       }
       const r = this.liquid.renderer;
-      const arg = yield evalToken3(this.arg, ctx);
+      const arg = yield evalToken4(this.arg, ctx);
       const hash = yield this.hash.render(ctx);
       const scope = ctx.getAll();
       const attrs = " " + Object.entries({ id: `${this.formConfig.id}_form`, ...hash }).reduce((acc, [key, value]) => {
@@ -15069,12 +15240,12 @@ function bind5(liquidSwell) {
 // src/liquid/tags/if.ts
 import {
   assert,
-  Tag as Tag5,
+  Tag as Tag7,
   Value as Value3,
   isTruthy as isTruthy2
 } from "liquidjs";
-function bind6(_liquidSwell) {
-  return class IfTag extends Tag5 {
+function bind8(_liquidSwell) {
+  return class IfTag extends Tag7 {
     branches = [];
     elseTemplates;
     constructor(tagToken, remainTokens, liquid, parser) {
@@ -15141,9 +15312,9 @@ function assertEmpty(predicate, message = `unexpected ${JSON.stringify(predicate
 }
 
 // src/liquid/tags/javascript.ts
-import { Tag as Tag6, TypeGuards as TypeGuards3 } from "liquidjs";
-function bind7(_liquidSwell) {
-  return class JavascriptTag extends Tag6 {
+import { Tag as Tag8, TypeGuards as TypeGuards3 } from "liquidjs";
+function bind9(_liquidSwell) {
+  return class JavascriptTag extends Tag8 {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
@@ -15168,9 +15339,9 @@ function bind7(_liquidSwell) {
 }
 
 // src/liquid/tags/layout.ts
-import { Tag as Tag7 } from "liquidjs";
-function bind8(liquidSwell) {
-  return class LayoutTag extends Tag7 {
+import { Tag as Tag9 } from "liquidjs";
+function bind10(liquidSwell) {
+  return class LayoutTag extends Tag9 {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -15186,9 +15357,9 @@ function bind8(liquidSwell) {
 }
 
 // src/liquid/tags/paginate.ts
-import { Tag as Tag8, Hash as Hash2, evalToken as evalToken4 } from "liquidjs";
-function bind9(liquidSwell) {
-  return class PaginateTag extends Tag8 {
+import { Tag as Tag10, Hash as Hash4, evalToken as evalToken5 } from "liquidjs";
+function bind11(liquidSwell) {
+  return class PaginateTag extends Tag10 {
     collection;
     pageSize;
     templates;
@@ -15203,7 +15374,7 @@ function bind9(liquidSwell) {
       }
       this.templates = [];
       this.collection = collection;
-      this.hash = new Hash2(this.tokenizer.remaining());
+      this.hash = new Hash4(this.tokenizer.remaining());
       const stream = parser.parseStream(remainTokens).on("tag:endpaginate", () => stream.stop()).on("template", (tpl) => {
         this.templates.push(tpl);
       }).on("end", () => {
@@ -15213,8 +15384,8 @@ function bind9(liquidSwell) {
     }
     *render(ctx, emitter) {
       const r = this.liquid.renderer;
-      const collection = yield evalToken4(this.collection, ctx);
-      const pageSize = Number(yield evalToken4(this.pageSize, ctx));
+      const collection = yield evalToken5(this.collection, ctx);
+      const pageSize = Number(yield evalToken5(this.pageSize, ctx));
       const hash = yield this.hash.render(ctx);
       if (!Number.isNaN(pageSize) && collection instanceof SwellStorefrontCollection && collection.limit !== pageSize) {
         yield collection._get({
@@ -15240,9 +15411,9 @@ function bind9(liquidSwell) {
 }
 
 // src/liquid/tags/render.ts
-import { assign } from "lodash-es";
-import { assert as assert2, evalToken as evalToken5, RenderTag as LiquidRenderTag } from "liquidjs";
-function bind10(liquidSwell) {
+import { assign as assign2 } from "lodash-es";
+import { assert as assert2, evalToken as evalToken6, RenderTag as LiquidRenderTag } from "liquidjs";
+function bind12(liquidSwell) {
   return class RenderTag extends LiquidRenderTag {
     *render(ctx, emitter) {
       const self = this;
@@ -15259,17 +15430,20 @@ function bind10(liquidSwell) {
       );
       const childCtx = ctx.spawn();
       const scope = childCtx.bottom();
-      assign(scope, yield hash.render(ctx));
+      assign2(scope, ctx.bottom());
       const parentSection = yield ctx._get(["section"]);
-      if (parentSection) assign(scope, { section: parentSection });
+      if (parentSection) assign2(scope, { section: parentSection });
+      const parentBlock = yield ctx._get(["block"]);
+      if (parentBlock) assign2(scope, { block: parentBlock });
+      assign2(scope, yield hash.render(ctx));
       if (self["with"]) {
         const { value, alias } = self["with"];
         const aliasName = alias || filename;
-        scope[aliasName] = yield evalToken5(value, ctx);
+        scope[aliasName] = yield evalToken6(value, ctx);
       }
       if (self["for"]) {
         const { value, alias } = self["for"];
-        let collection = yield evalToken5(value, ctx);
+        let collection = yield evalToken6(value, ctx);
         collection = yield resolveEnumerable(collection);
         scope["forloop"] = new ForloopDrop(
           collection.length,
@@ -15312,13 +15486,13 @@ function* renderFilePath(file, ctx, liquid) {
     default:
       break;
   }
-  return yield evalToken5(file, ctx);
+  return yield evalToken6(file, ctx);
 }
 
 // src/liquid/tags/section.ts
-import { Tag as Tag9 } from "liquidjs";
-function bind11(liquidSwell) {
-  return class SectionTag extends Tag9 {
+import { Tag as Tag11 } from "liquidjs";
+function bind13(liquidSwell) {
+  return class SectionTag extends Tag11 {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -15369,10 +15543,10 @@ function bind11(liquidSwell) {
 }
 
 // src/liquid/tags/sections.ts
-import { Tag as Tag10 } from "liquidjs";
+import { Tag as Tag12 } from "liquidjs";
 import JSON54 from "json5";
-function bind12(liquidSwell) {
-  return class SectionsTag extends Tag10 {
+function bind14(liquidSwell) {
+  return class SectionsTag extends Tag12 {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -15412,9 +15586,9 @@ function bind12(liquidSwell) {
 }
 
 // src/liquid/tags/style.ts
-import { Tag as Tag11, TypeGuards as TypeGuards4 } from "liquidjs";
-function bind13(_liquidSwell) {
-  return class StyleTag extends Tag11 {
+import { Tag as Tag13, TypeGuards as TypeGuards4 } from "liquidjs";
+function bind15(_liquidSwell) {
+  return class StyleTag extends Tag13 {
     templates;
     hash;
     constructor(token, remainTokens, liquid, parser) {
@@ -15446,9 +15620,9 @@ function bind13(_liquidSwell) {
 }
 
 // src/liquid/tags/stylesheet.ts
-import { Tag as Tag12, TypeGuards as TypeGuards5 } from "liquidjs";
-function bind14(_liquidSwell) {
-  return class StyleSheetTag extends Tag12 {
+import { Tag as Tag14, TypeGuards as TypeGuards5 } from "liquidjs";
+function bind16(_liquidSwell) {
+  return class StyleSheetTag extends Tag14 {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
@@ -15471,8 +15645,8 @@ function bind14(_liquidSwell) {
 }
 
 // src/liquid/tags/shopify/include.ts
-import { assert as assert3, evalToken as evalToken6, IncludeTag as LiquidIncludeTag } from "liquidjs";
-function bind15(liquidSwell) {
+import { assert as assert3, evalToken as evalToken7, IncludeTag as LiquidIncludeTag } from "liquidjs";
+function bind17(liquidSwell) {
   return class IncludeTag extends LiquidIncludeTag {
     *render(ctx, emitter) {
       const { hash } = this;
@@ -15487,7 +15661,7 @@ function bind15(liquidSwell) {
       ctx.setRegister("blockMode", 0);
       const scope = yield hash.render(ctx);
       if (this.withVar) {
-        scope[filepath] = yield evalToken6(this.withVar, ctx);
+        scope[filepath] = yield evalToken7(this.withVar, ctx);
       }
       ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope);
       const output = yield liquidSwell.getComponentPath(filepath).then((path) => liquidSwell.getThemeConfig(path)).then((themeConfig) => liquidSwell.renderTemplate(themeConfig, ctx));
@@ -15499,10 +15673,10 @@ function bind15(liquidSwell) {
 }
 
 // src/liquid/tags/shopify/schema.ts
-import { Tag as Tag13 } from "liquidjs";
+import { Tag as Tag15 } from "liquidjs";
 import JSON55 from "json5";
-function bind16(liquidSwell) {
-  return class SchemaTag extends Tag13 {
+function bind18(liquidSwell) {
+  return class SchemaTag extends Tag15 {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
@@ -15524,6 +15698,7 @@ function bind16(liquidSwell) {
         liquidSwell.lastSchema = void 0;
         if (typeof jsonOutput === "string") {
           liquidSwell.lastSchema = JSON55.parse(jsonOutput);
+          expandThemeBlocks(liquidSwell);
         }
       } catch (err) {
         console.warn(err);
@@ -15533,11 +15708,22 @@ function bind16(liquidSwell) {
     }
   };
 }
+function expandThemeBlocks(liquidSwell) {
+  const blocks = liquidSwell.lastSchema?.blocks;
+  if (!Array.isArray(blocks)) {
+    return;
+  }
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type === "@theme") {
+      blocks.splice(i, 1, ...liquidSwell.theme.getAllThemeBlockSchemas());
+    }
+  }
+}
 
 // src/liquid/tags/inline_editable.ts
-import { Tag as Tag14 } from "liquidjs";
-function bind17(_liquidSwell) {
-  return class InlineEditableTag extends Tag14 {
+import { Tag as Tag16 } from "liquidjs";
+function bind19(_liquidSwell) {
+  return class InlineEditableTag extends Tag16 {
     key;
     value;
     constructor(token, remainTokens, liquid, _parser) {
@@ -15565,129 +15751,131 @@ var tags = {
   assign: bind,
   case: bind2,
   comment: bind3,
-  for: bind4,
-  form: bind5,
-  if: bind6,
-  javascript: bind7,
-  layout: bind8,
-  paginate: bind9,
-  render: bind10,
-  section: bind11,
-  sections: bind12,
-  style: bind13,
+  content_for: bind4,
+  doc: bind5,
+  for: bind6,
+  form: bind7,
+  if: bind8,
+  javascript: bind9,
+  layout: bind10,
+  paginate: bind11,
+  render: bind12,
+  section: bind13,
+  sections: bind14,
+  style: bind15,
   // Shopify compatibility only
-  include: bind15,
-  schema: bind16,
-  stylesheet: bind14,
+  include: bind17,
+  schema: bind18,
+  stylesheet: bind16,
   // Swell only
-  inline_editable: bind17
+  inline_editable: bind19
 };
 function bindTags(liquidSwell) {
   Object.entries(tags).forEach(
-    ([tag, bind67]) => liquidSwell.registerTag(tag, bind67(liquidSwell))
+    ([tag, bind70]) => liquidSwell.registerTag(tag, bind70(liquidSwell))
   );
 }
 
 // src/liquid/filters/asset_url.ts
-function bind18(liquidSwell) {
+function bind20(liquidSwell) {
   return function filterAssetUrl(assetPath) {
     return liquidSwell.getAssetUrl(assetPath).then((url) => url || "");
   };
 }
 
 // src/liquid/filters/brightness_difference.ts
-function bind19(_liquidSwell) {
+function bind21(_liquidSwell) {
   return (color1, color2) => {
     return ThemeColor.get(color1).brightnessDifference(ThemeColor.get(color2));
   };
 }
 
 // src/liquid/filters/color_brightness.ts
-function bind20(_liquidSwell) {
+function bind22(_liquidSwell) {
   return (color) => {
     return ThemeColor.get(color).brightness();
   };
 }
 
 // src/liquid/filters/color_contrast.ts
-function bind21(_liquidSwell) {
+function bind23(_liquidSwell) {
   return (color1, color2) => {
     return ThemeColor.get(color1).contrast(ThemeColor.get(color2));
   };
 }
 
 // src/liquid/filters/color_darken.ts
-function bind22(_liquidSwell) {
+function bind24(_liquidSwell) {
   return (color, percent) => {
     return ThemeColor.get(color).darken(percent);
   };
 }
 
 // src/liquid/filters/color_desaturate.ts
-function bind23(_liquidSwell) {
+function bind25(_liquidSwell) {
   return (color, value) => {
     return ThemeColor.get(color).desaturate(value);
   };
 }
 
 // src/liquid/filters/color_difference.ts
-function bind24(_liquidSwell) {
+function bind26(_liquidSwell) {
   return (color1, color2) => {
     return ThemeColor.get(color1).difference(ThemeColor.get(color2));
   };
 }
 
 // src/liquid/filters/color_extract.ts
-function bind25(_liquidSwell) {
+function bind27(_liquidSwell) {
   return (color, field) => {
     return ThemeColor.get(color).extract(field);
   };
 }
 
 // src/liquid/filters/color_lighten.ts
-function bind26(_liquidSwell) {
+function bind28(_liquidSwell) {
   return (color, percent) => {
     return ThemeColor.get(color).lighten(percent);
   };
 }
 
 // src/liquid/filters/color_mix.ts
-function bind27(_liquidSwell) {
+function bind29(_liquidSwell) {
   return (color1, color2, ratio) => {
     return ThemeColor.get(color1).mix(ThemeColor.get(color2), ratio);
   };
 }
 
 // src/liquid/filters/color_modify.ts
-function bind28(_liquidSwell) {
+function bind30(_liquidSwell) {
   return function filterColorModify(color, field, value) {
     return ThemeColor.get(color).modify(field, Number(value) || 0);
   };
 }
 
 // src/liquid/filters/color_saturate.ts
-function bind29(_liquidSwell) {
+function bind31(_liquidSwell) {
   return (color, value) => {
     return ThemeColor.get(color).saturate(value);
   };
 }
 
 // src/liquid/filters/color_to_hex.ts
-function bind30(_liquidSwell) {
+function bind32(_liquidSwell) {
   return (color) => {
     return ThemeColor.get(color).hex();
   };
 }
 
 // src/liquid/filters/color_to_hsl.ts
-function bind31(_liquidSwell) {
+function bind33(_liquidSwell) {
   return (color) => {
     return ThemeColor.get(color).hsl();
   };
 }
 
 // src/liquid/filters/color_to_rgb.ts
-function bind32(_liquidSwell) {
+function bind34(_liquidSwell) {
   return (color, alpha) => {
     return alpha !== void 0 ? ThemeColor.get(color).rgba(alpha) : ThemeColor.get(color).rgb();
   };
@@ -15695,7 +15883,7 @@ function bind32(_liquidSwell) {
 
 // src/liquid/filters/date.ts
 import strftime from "strftime";
-function bind33(_liquidSwell) {
+function bind35(_liquidSwell) {
   return (dateValue, ...params) => {
     const date = ensureDate(dateValue);
     const { format } = getDateFilterParams(params);
@@ -15753,7 +15941,7 @@ function applyStrftimeFormat(format, date) {
 }
 
 // src/liquid/filters/date_next_interval.ts
-function bind34(_liquidSwell) {
+function bind36(_liquidSwell) {
   return (dateValue, interval, intervalCount) => {
     const date = ensureDate(dateValue);
     const result = getNextIntervalDate(date, interval, Number(intervalCount));
@@ -15805,7 +15993,7 @@ function time(date) {
 }
 
 // src/liquid/filters/default_errors.ts
-function bind35(_liquidSwell) {
+function bind37(_liquidSwell) {
   return async function filterDefaultError(errors) {
     if (!errors) {
       return "";
@@ -15831,7 +16019,7 @@ function bind35(_liquidSwell) {
 }
 
 // src/liquid/filters/divided_by.ts
-function bind36(_liquidSwell) {
+function bind38(_liquidSwell) {
   return (dividend, divisor, integerArithmetic) => {
     if (!isNumber(dividend) || !isNumber(divisor)) {
       return dividend;
@@ -15842,7 +16030,7 @@ function bind36(_liquidSwell) {
 
 // src/liquid/filters/embedded_content.ts
 import { unescape } from "lodash-es";
-function bind37(_liquidSwell) {
+function bind39(_liquidSwell) {
   return (value, tag = "iframe") => {
     const escapeIframes = value.replaceAll(`<${tag}`, `&lt;${tag}`).replaceAll(`</${tag}`, `&lt;/${tag}`);
     const removeTags = escapeIframes.replaceAll(/<(.*?)>/gi, "");
@@ -15854,7 +16042,7 @@ function bind37(_liquidSwell) {
 
 // src/liquid/filters/escape.ts
 import { escape } from "lodash-es";
-function bind38(_liquidSwell) {
+function bind40(_liquidSwell) {
   return function escapeTag(input) {
     if (!input?.startsWith) {
       return input;
@@ -15867,7 +16055,7 @@ function bind38(_liquidSwell) {
 }
 
 // src/liquid/filters/font_face.ts
-function bind39(_liquidSwell) {
+function bind41(_liquidSwell) {
   return (fontSetting, ...params) => {
     if (!fontSetting) {
       return null;
@@ -15879,14 +16067,14 @@ function bind39(_liquidSwell) {
 }
 
 // src/liquid/filters/font_modify.ts
-function bind40(_liquidSwell) {
+function bind42(_liquidSwell) {
   return (fontSetting, prop, value) => {
     return ThemeFont.clone(fontSetting).modify(prop, value);
   };
 }
 
 // src/liquid/filters/font_url.ts
-function bind41(_liquidSwell) {
+function bind43(_liquidSwell) {
   return (fontSetting) => {
     return ThemeFont.get(fontSetting).url();
   };
@@ -15936,14 +16124,14 @@ var format_address_default = {
 
 // src/liquid/filters/handleize.ts
 import { kebabCase } from "lodash-es";
-function bind42(_liquidSwell) {
+function bind44(_liquidSwell) {
   return function filterHandleize(handle) {
     return kebabCase(handle);
   };
 }
 
 // src/liquid/filters/image_tag.ts
-function bind43(_liquidSwell) {
+function bind45(_liquidSwell) {
   return function filterImageTag(imageUrl, ...params) {
     imageUrl = String(imageUrl || "");
     let {
@@ -16107,7 +16295,7 @@ var filterDefinition = {
 var image_url_default = filterDefinition;
 
 // src/liquid/filters/inline_asset_content.ts
-function bind44(liquidSwell) {
+function bind46(liquidSwell) {
   return async (assetPath) => {
     const config = await liquidSwell.theme.getThemeConfig(
       `theme/assets/${assetPath}`
@@ -16117,14 +16305,14 @@ function bind44(liquidSwell) {
 }
 
 // src/liquid/filters/json.ts
-function bind45(_liquidSwell) {
+function bind47(_liquidSwell) {
   return async function filterJson(input, space = 0) {
     return jsonStringifyAsync(input, space);
   };
 }
 
 // src/liquid/filters/json_pretty.ts
-function bind46(_liquidSwell) {
+function bind48(_liquidSwell) {
   return async function filterJsonPretty(input, space = 2) {
     const output = await jsonStringifyAsync(input, space);
     return `<pre>${output}</pre>`;
@@ -16134,7 +16322,7 @@ function bind46(_liquidSwell) {
 // src/liquid/filters/locale_flag.ts
 import { hasFlag } from "country-flag-icons";
 import * as flags from "country-flag-icons/string/1x1";
-function bind47(_liquidSwell) {
+function bind49(_liquidSwell) {
   return (localeCode) => {
     if (typeof localeCode !== "string") {
       return flags.US;
@@ -16145,7 +16333,7 @@ function bind47(_liquidSwell) {
 }
 
 // src/liquid/filters/minus.ts
-function bind48(_liquidSwell) {
+function bind50(_liquidSwell) {
   return (first, second) => {
     const firstValue = isNumber(first) ? first : 0;
     const secondValue = isNumber(second) ? second : 0;
@@ -16154,7 +16342,7 @@ function bind48(_liquidSwell) {
 }
 
 // src/liquid/filters/money.ts
-function bind49(liquidSwell) {
+function bind51(liquidSwell) {
   return function filterMoney(value) {
     const amount = getMoneyAmount(liquidSwell, value);
     return liquidSwell.renderCurrency(amount);
@@ -16171,7 +16359,7 @@ function getMoneyAmount(liquidSwell, value) {
 }
 
 // src/liquid/filters/money_with_currency.ts
-function bind50(liquidSwell) {
+function bind52(liquidSwell) {
   return function filterMoneyWithCurrency(value) {
     const { currency } = liquidSwell.theme.swell.getStorefrontLocalization();
     const amount = getMoneyAmount(liquidSwell, value);
@@ -16180,7 +16368,7 @@ function bind50(liquidSwell) {
 }
 
 // src/liquid/filters/money_without_currency.ts
-function bind51(liquidSwell) {
+function bind53(liquidSwell) {
   return function filterMoneyWithoutCurrency(value) {
     const amount = getMoneyAmount(liquidSwell, value);
     return liquidSwell.renderCurrency(amount).replace(/[^0-9.,]/g, "");
@@ -16188,30 +16376,45 @@ function bind51(liquidSwell) {
 }
 
 // src/liquid/filters/money_without_trailing_zeros.ts
-function bind52(liquidSwell) {
+function bind54(liquidSwell) {
   return function filterMoneyWithoutTrailingZeros(value) {
     const amount = getMoneyAmount(liquidSwell, value);
     return liquidSwell.renderCurrency(amount).split(".")[0].split(",")[0];
   };
 }
 
+// src/liquid/filters/preload_tag.ts
+function bind55(_liquidSwell) {
+  return function filterPreloadTag(assetUrl, ...params) {
+    if (!assetUrl) {
+      return "";
+    }
+    const { as } = paramsToProps(params);
+    let attributes = "";
+    if (typeof as === "string" && as) {
+      attributes += `as="${as}"`;
+    }
+    return `<link href="${assetUrl}" rel="preload" ${attributes} />`;
+  };
+}
+
 // src/liquid/filters/script_tag.ts
-function bind53(_liquidSwell) {
+function bind56(_liquidSwell) {
   return function filterScriptTag(assetUrl) {
     return `<script src="${assetUrl}" type="text/javascript"></script>`;
   };
 }
 
 // src/liquid/filters/stylesheet_tag.ts
-function bind54(_liquidSwell) {
+function bind57(_liquidSwell) {
   return function filterStyleSheetTag(assetUrl) {
     return `<link href="${assetUrl}" rel="stylesheet" type="text/css" media="all" />`;
   };
 }
 
 // src/liquid/filters/time_tag.ts
-function bind55(_liquidSwell) {
-  const dateFilter = bind33(_liquidSwell);
+function bind58(_liquidSwell) {
+  const dateFilter = bind35(_liquidSwell);
   return (dateValue, ...params) => {
     const date = ensureDate(dateValue);
     const formattedDate = dateFilter(dateValue, ...params);
@@ -16221,7 +16424,7 @@ function bind55(_liquidSwell) {
 }
 
 // src/liquid/filters/translate.ts
-function bind56(liquidSwell) {
+function bind59(liquidSwell) {
   return async function filterTranslate(key, params) {
     const props = params && paramsToProps(params);
     const str = await liquidSwell.renderTranslation(key, props);
@@ -16230,7 +16433,7 @@ function bind56(liquidSwell) {
 }
 
 // src/liquid/filters/where.ts
-function bind57(_liquidSwell) {
+function bind60(_liquidSwell) {
   return function* filterWhere(arr, property, expected) {
     const results = [];
     const list = yield resolveEnumerable(arr);
@@ -16284,7 +16487,7 @@ function getSizesFromParam(param) {
     height: height ? Number(height) : void 0
   };
 }
-function bind58(liquidSwell) {
+function bind61(liquidSwell) {
   return async function filterAssetImgUrl(assetPath, size = "small") {
     const imageUrl = await liquidSwell.getAssetUrl(assetPath).then((url) => url || "");
     const sizes = getSizesFromParam(size);
@@ -16300,14 +16503,14 @@ function bind58(liquidSwell) {
 }
 
 // src/liquid/filters/shopify/hex_to_rgba.ts
-function bind59(_liquidSwell) {
+function bind62(_liquidSwell) {
   return (color, alpha) => {
     return ThemeColor.get(color).rgba(alpha || 1);
   };
 }
 
 // src/liquid/filters/shopify/img_url.ts
-function bind60(liquidSwell) {
+function bind63(liquidSwell) {
   return async function filterImgUrl(input, ...params) {
     const url = await getImageUrlFromInput(input, liquidSwell);
     if (typeof url !== "string" || url === "") {
@@ -16345,14 +16548,14 @@ var item_count_for_variant_default = {
 };
 
 // src/liquid/filters/shopify/payment_button.ts
-function bind61(_liquidSwell) {
+function bind64(_liquidSwell) {
   return (form) => {
     return `<button style="display: block; visibility: hidden;"></button>`;
   };
 }
 
 // src/liquid/filters/shopify/payment_terms.ts
-function bind62(_liquidSwell) {
+function bind65(_liquidSwell) {
   return (form) => {
     return null;
   };
@@ -16454,7 +16657,7 @@ var svgs = {
 var placeholder_svgs_default = svgs;
 
 // src/liquid/filters/shopify/placeholder_svg_tag.ts
-function bind63(_liquidSwell) {
+function bind66(_liquidSwell) {
   return function filterPlaceholderSvgTag(name, className) {
     const svg = placeholder_svgs_default[name];
     if (typeof svg === "object" && svg !== null) {
@@ -16465,7 +16668,7 @@ function bind63(_liquidSwell) {
 }
 
 // src/liquid/filters/shopify/shopify_asset_url.ts
-function bind64(_liquidSwell) {
+function bind67(_liquidSwell) {
   return function filterShopifyAssetUrl(input) {
     if (typeof input === "string") {
       switch (input) {
@@ -16490,7 +16693,7 @@ function bind64(_liquidSwell) {
 }
 
 // src/liquid/filters/shopify/structured_data.ts
-function bind65(_liquidSwell) {
+function bind68(_liquidSwell) {
   return async function filterStructuredData(input) {
     let value = input;
     if (value instanceof StorefrontResource) {
@@ -16568,7 +16771,7 @@ function convertToSchemaOrgProductGroup(product) {
 }
 
 // src/liquid/filters/inline_editable.ts
-function bind66(_liquidSwell) {
+function bind69(_liquidSwell) {
   return (value, key) => {
     if (typeof value === "object" && "value" in value) {
       value = value.value;
@@ -16579,64 +16782,65 @@ function bind66(_liquidSwell) {
 
 // src/liquid/filters/index.ts
 var filters = {
-  asset_url: bind18,
-  brightness_difference: bind19,
-  color_brightness: bind20,
-  color_contrast: bind21,
-  color_darken: bind22,
-  color_desaturate: bind23,
-  color_difference: bind24,
-  color_extract: bind25,
-  color_lighten: bind26,
-  color_mix: bind27,
-  color_modify: bind28,
-  color_saturate: bind29,
-  color_to_hex: bind30,
-  color_to_hsl: bind31,
-  color_to_rgb: bind32,
-  date_next_interval: bind34,
-  date: bind33,
-  default_errors: bind35,
-  divided_by: bind36,
-  embedded_content: bind37,
-  escape: bind38,
-  font_face: bind39,
-  font_modify: bind40,
-  font_url: bind41,
+  asset_url: bind20,
+  brightness_difference: bind21,
+  color_brightness: bind22,
+  color_contrast: bind23,
+  color_darken: bind24,
+  color_desaturate: bind25,
+  color_difference: bind26,
+  color_extract: bind27,
+  color_lighten: bind28,
+  color_mix: bind29,
+  color_modify: bind30,
+  color_saturate: bind31,
+  color_to_hex: bind32,
+  color_to_hsl: bind33,
+  color_to_rgb: bind34,
+  date_next_interval: bind36,
+  date: bind35,
+  default_errors: bind37,
+  divided_by: bind38,
+  embedded_content: bind39,
+  escape: bind40,
+  font_face: bind41,
+  font_modify: bind42,
+  font_url: bind43,
   format_address: format_address_default,
-  handle: bind42,
+  handle: bind44,
   // alias
-  handleize: bind42,
-  image_tag: bind43,
+  handleize: bind44,
+  image_tag: bind45,
   image_url: image_url_default,
-  inline_asset_content: bind44,
-  json: bind45,
-  json_pretty: bind46,
-  locale_flag: bind47,
-  minus: bind48,
-  money: bind49,
-  money_with_currency: bind50,
-  money_without_currency: bind51,
-  money_without_trailing_zeros: bind52,
-  script_tag: bind53,
-  stylesheet_tag: bind54,
-  time_tag: bind55,
-  translate: bind56,
-  t: bind56,
+  inline_asset_content: bind46,
+  json: bind47,
+  json_pretty: bind48,
+  locale_flag: bind49,
+  minus: bind50,
+  money: bind51,
+  money_with_currency: bind52,
+  money_without_currency: bind53,
+  money_without_trailing_zeros: bind54,
+  preload_tag: bind55,
+  script_tag: bind56,
+  stylesheet_tag: bind57,
+  time_tag: bind58,
+  translate: bind59,
+  t: bind59,
   // alias
-  where: bind57,
+  where: bind60,
   // Shopify compatibility only
-  asset_img_url: bind58,
-  hex_to_rgba: bind59,
-  img_url: bind60,
+  asset_img_url: bind61,
+  hex_to_rgba: bind62,
+  img_url: bind63,
   item_count_for_variant: item_count_for_variant_default,
-  payment_button: bind61,
-  payment_terms: bind62,
-  placeholder_svg_tag: bind63,
-  shopify_asset_url: bind64,
-  structured_data: bind65,
+  payment_button: bind64,
+  payment_terms: bind65,
+  placeholder_svg_tag: bind66,
+  shopify_asset_url: bind67,
+  structured_data: bind68,
   // Swell only
-  inline_editable: bind66
+  inline_editable: bind69
 };
 function bindFilters(liquidSwell) {
   for (const [tag, handler] of Object.entries(filters)) {
@@ -16650,8 +16854,8 @@ function bindFilters(liquidSwell) {
     }
   }
 }
-function bindWithResolvedProps(liquidSwell, bind67, resolve = []) {
-  const handler = bind67(liquidSwell);
+function bindWithResolvedProps(liquidSwell, bind70, resolve = []) {
+  const handler = bind70(liquidSwell);
   if (!Array.isArray(resolve)) {
     return handler;
   }
@@ -16778,10 +16982,16 @@ var ThemeColor = class _ThemeColor extends Drop16 {
     return this.color.darken(percent / 100).hex().toLowerCase();
   }
   rgb() {
-    return this.color.rgb().toString();
+    return `${this.red} ${this.green} ${this.blue}`;
   }
   rgba(alpha) {
-    return this.color.alpha(alpha).rgb().toString();
+    const colorValues = this.color.object();
+    const alphaValue = alpha || colorValues.alpha;
+    const rgb = this.rgb();
+    if (alphaValue === void 0) {
+      return rgb;
+    }
+    return `${rgb} / ${Number(alphaValue).toFixed(2)}`;
   }
   hsl() {
     return this.color.hsl().round().toString();
@@ -16886,6 +17096,7 @@ var LiquidSwell31 = class extends Liquid3 {
   extName;
   componentsDir;
   sectionsDir;
+  blocksDir;
   lastSchema;
   constructor({
     theme,
@@ -16903,7 +17114,8 @@ var LiquidSwell31 = class extends Liquid3 {
     layoutName,
     extName,
     componentsDir,
-    sectionsDir
+    sectionsDir,
+    blocksDir
   }) {
     getThemeConfig = getThemeConfig || theme.getThemeConfig.bind(theme);
     extName = extName || "liquid";
@@ -16932,6 +17144,7 @@ var LiquidSwell31 = class extends Liquid3 {
     this.extName = extName;
     this.componentsDir = componentsDir || "components";
     this.sectionsDir = sectionsDir || "sections";
+    this.blocksDir = blocksDir || "blocks";
     this.lastSchema = void 0;
     bindTags(this);
     bindFilters(this);
@@ -16954,6 +17167,9 @@ var LiquidSwell31 = class extends Liquid3 {
   async getSectionGroupPath(sectionName) {
     return await this.resolveFilePathByType("sections", `${sectionName}.json`) || resolveFilePath(`${this.sectionsDir}/${sectionName}`, "json");
   }
+  async getThemeBlockPath(blockName) {
+    return await this.resolveFilePathByType("blocks", blockName) || resolveFilePath(`${this.blocksDir}/${blockName}`, this.extName);
+  }
 };
 function resolveFilePath(fileName, extName) {
   return `theme/${fileName}.${extName}`;
@@ -18665,6 +18881,30 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     const configs = this.getThemeConfigsByPath("theme/sections/");
     return getAllSections(configs, this.getTemplateSchema.bind(this));
   }
+  /**
+   * Returns all theme block schemas from /blocks folder.
+   */
+  getAllThemeBlockSchemas() {
+    const schemas = [];
+    const configs = this.getThemeConfigsByPath("theme/blocks/");
+    for (const config of configs.values()) {
+      const { name, file_path: filePath, file_data: fileData } = config;
+      const rawSchema = extractSchemaTag(fileData, true);
+      if (!rawSchema) {
+        continue;
+      }
+      try {
+        const schema = JSON56.parse(rawSchema);
+        if (!schema.type) {
+          schema.type = name;
+        }
+        schemas.push(schema);
+      } catch (error) {
+        console.warn(`Invalid schema in block: ${filePath}`, error);
+      }
+    }
+    return schemas;
+  }
   async getPageSections(sectionGroup, resolveSettings = true) {
     const sectionConfigs = await getPageSections(
       sectionGroup,
@@ -19025,14 +19265,14 @@ function parseJsonConfig(config) {
     return {};
   }
 }
-function extractSchemaTag(template) {
+function extractSchemaTag(template, inner = false) {
   const list = template.match(
     /\{%-?\s*schema\s*-?%\}(.*)\{%-?\s*endschema\s*-?%\}/s
   );
   if (list === null) {
     return template;
   }
-  return list[0];
+  return inner ? list[1] : list[0];
 }
 function withSuffix(path, suffix) {
   return suffix ? `${path}.${suffix}` : path;