@augeo/smelt 1.2.2

package/biome.json

@@ -0,0 +1,58 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": false,
+		"includes": [
+			"lib/**",
+			"!lib/*.generated.ts",
+			"src/**",
+			"tests/**",
+			"scripts/**",
+			"tsdown.config.ts",
+			"vitest.config.ts",
+			"example/src/**",
+			"example/vitest.config.ts",
+			"example/package.json",
+			"example/tsconfig.json",
+			"package.json",
+			"tsconfig.json",
+			"src/tsconfig.json",
+			"biome.json",
+			".prettierrc.cjs"
+		]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab",
+		"lineWidth": 80
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"suspicious": {
+				"noDuplicateTestHooks": "off"
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double",
+			"trailingCommas": "all"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on",
+				"useSortedProperties": "on"
+			}
+		}
+	}
+}

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { build } from "esbuild";
+import { watch } from "chokidar";
+//#region lib/resolver.ts
+const TYPE_NAMES = [
+	"sections",
+	"blocks",
+	"components"
+];
+async function resolveLayers(layers) {
+	const perLayerComponents = await Promise.all(layers.map(walkLayer));
+	const allKeys = /* @__PURE__ */ new Map();
+	perLayerComponents.flat().forEach(({ type, segments }) => {
+		const key = `${type}:${segments.join("/")}`;
+		if (!allKeys.has(key)) allKeys.set(key, {
+			type,
+			segments
+		});
+	});
+	return (await Promise.all(Array.from(allKeys.values()).map(async ({ type, segments }) => {
+		const [liquid, ts, css, test, schema] = await Promise.all([
+			firstExisting(layers, segments, ".liquid"),
+			firstExisting(layers, segments, ".ts"),
+			firstExisting(layers, segments, ".css"),
+			firstExisting(layers, segments, ".test.ts"),
+			firstExisting(layers, segments, ".schema.ts")
+		]);
+		if (!liquid) return void 0;
+		const component = {
+			type,
+			segments,
+			liquid
+		};
+		if (ts) component.ts = ts;
+		if (css) component.css = css;
+		if (test) component.test = test;
+		if (schema) component.schema = schema;
+		return component;
+	}))).filter((component) => component !== void 0);
+}
+async function walkLayer(layer) {
+	const sourceRoot = join(layer.path, "src");
+	if (!await exists$1(sourceRoot)) return [];
+	return (await Promise.all(TYPE_NAMES.map(async (type) => {
+		const typeDir = join(sourceRoot, type);
+		if (!await exists$1(typeDir)) return [];
+		return walkType(typeDir, type, [type]);
+	}))).flat();
+}
+async function walkType(directory, type, segments) {
+	const directories = (await readdir(directory, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+	return (await Promise.all(directories.map(async (entry) => {
+		const subdirectory = join(directory, entry.name);
+		if (TYPE_NAMES.includes(entry.name)) return walkType(subdirectory, entry.name, [...segments, entry.name]);
+		const componentSegments = [...segments, entry.name];
+		const here = await exists$1(join(subdirectory, `${entry.name}.liquid`)) ? [{
+			type,
+			segments: componentSegments
+		}] : [];
+		const deeper = await walkType(subdirectory, type, componentSegments);
+		return [...here, ...deeper];
+	}))).flat();
+}
+async function firstExisting(layers, segments, extension) {
+	const last = segments[segments.length - 1];
+	const relativePath = join("src", ...segments, `${last}${extension}`);
+	const winner = (await Promise.all(layers.map(async (layer) => ({
+		layer,
+		path: join(layer.path, relativePath),
+		exists: await exists$1(join(layer.path, relativePath))
+	})))).find((candidate) => candidate.exists);
+	return winner ? {
+		path: winner.path,
+		layer: winner.layer
+	} : void 0;
+}
+async function exists$1(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region lib/build/build.ts
+const BUILT_PREFIX = "built--";
+const BUILT_FILE_PATTERN = /^_?built--/;
+const TYPE_TO_OUTPUT_DIRECTORY = {
+	sections: "sections",
+	blocks: "blocks",
+	components: "snippets"
+};
+async function build$2(context) {
+	const outputRoot = context.layers[0]?.path;
+	if (!outputRoot) throw new Error("build() requires at least one layer.");
+	const components = await resolveLayers(context.layers);
+	await cleanBuiltOutputs(outputRoot);
+	const lookup = new Map(components.map((component) => [component.segments.join("/"), component]));
+	await Promise.all(components.map((component) => buildComponent(component, lookup, outputRoot)));
+	return components.length;
+}
+async function cleanBuiltOutputs(outputRoot) {
+	await Promise.all(Object.values(TYPE_TO_OUTPUT_DIRECTORY).map(async (directory) => {
+		const directoryPath = join(outputRoot, directory);
+		if (!await exists(directoryPath)) return;
+		const entries = await readdir(directoryPath);
+		await Promise.all(entries.filter((entry) => BUILT_FILE_PATTERN.test(entry)).map((entry) => rm(join(directoryPath, entry))));
+	}));
+}
+async function buildComponent(component, lookup, outputRoot) {
+	const source = await readFile(component.liquid.path, "utf-8");
+	assertNoInlineSchema(source, component);
+	const body = rewriteRenders(source, component, lookup);
+	const sections = [banner(component), body.trimEnd()];
+	if (component.schema) {
+		const merged = mergePrivateBlocks(await loadSchema(component.schema), component, lookup);
+		sections.push(renderSchemaBlock(merged));
+	}
+	if (component.css) {
+		const css = await readFile(component.css.path, "utf-8");
+		sections.push(wrapEmbedded("stylesheet", css));
+	}
+	if (component.ts) sections.push(wrapEmbedded("javascript", await bundleJs(component.ts)));
+	const liquid = `${sections.join("\n\n")}\n`;
+	const outputDirectory = join(outputRoot, TYPE_TO_OUTPUT_DIRECTORY[component.type]);
+	const outputPath = join(outputDirectory, `${builtNameOf(component)}.liquid`);
+	await mkdir(outputDirectory, { recursive: true });
+	await writeFile(outputPath, liquid);
+}
+function assertNoInlineSchema(source, component) {
+	if (!/\{%-?\s*schema\s*-?%\}/.test(source)) return;
+	const last = component.segments[component.segments.length - 1];
+	throw new Error(`Inline {% schema %} block in ${sourcePathForComponent(component)}. Schemas must live in a sibling ${last}.schema.ts file — import { defineSchemaSection } (or defineSchemaBlock) from "@augeo/smelt/schema".`);
+}
+async function loadSchema(schemaSource) {
+	const code = await bundle(schemaSource.path, {
+		format: "esm",
+		platform: "node",
+		target: "node24"
+	});
+	const loaded = await import(`data:text/javascript,${encodeURIComponent(code)}`);
+	if (loaded.schema === void 0) {
+		const available = Object.keys(loaded).join(", ") || "no exports";
+		throw new Error(`${schemaSource.path} must export a named 'schema' (found: ${available}).`);
+	}
+	return loaded.schema;
+}
+function renderSchemaBlock(schema) {
+	return `{% schema %}\n${JSON.stringify(schema, null, 2)}\n{% endschema %}`;
+}
+/**
+* A block is "private" when its segments were reached through a nested
+* `blocks/` type marker — i.e. there is a `blocks` segment at any position
+* after the root. That covers both a section/component owning private blocks
+* (`sections/hero/blocks/headline`) and a public block owning its own private
+* blocks (`blocks/promo/blocks/item`). Shopify treats files prefixed `_` in
+* `blocks/` as hidden from the merchant picker; we map our nested authoring
+* convention onto that filename convention.
+*/
+function isPrivateBlock(component) {
+	if (component.type !== "blocks") return false;
+	return component.segments.slice(1).includes("blocks");
+}
+/** Filename minus `.liquid` — also the Shopify-facing `type` for blocks. */
+function builtNameOf(component) {
+	return `${isPrivateBlock(component) ? "_" : ""}${BUILT_PREFIX}${component.segments.join("--")}`;
+}
+/**
+* Auto-merge immediate private children (blocks under `<parent>/blocks/`) into
+* the parent's `blocks: [...]` schema array. Discovered children are sorted
+* by directory name and prepended; any explicitly-listed entries the author
+* wrote are appended after.
+*/
+function mergePrivateBlocks(schema, component, lookup) {
+	if (!isPlainObject(schema)) return schema;
+	const children = findPrivateChildren(component, lookup);
+	if (children.length === 0) return schema;
+	const discovered = children.map((child) => ({ type: builtNameOf(child) }));
+	const explicit = Array.isArray(schema.blocks) ? schema.blocks : [];
+	return {
+		...schema,
+		blocks: [...discovered, ...explicit]
+	};
+}
+function findPrivateChildren(component, lookup) {
+	const parent = component.segments;
+	return Array.from(lookup.values()).filter((other) => {
+		if (other.type !== "blocks") return false;
+		if (other.segments.length !== parent.length + 2) return false;
+		if (other.segments[parent.length] !== "blocks") return false;
+		return parent.every((segment, index) => other.segments[index] === segment);
+	}).sort((a, b) => (a.segments[a.segments.length - 1] ?? "").localeCompare(b.segments[b.segments.length - 1] ?? ""));
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function banner(component) {
+	return `{%- comment -%}
+	GENERATED FROM ${sourcePathForComponent(component)} — do not edit this file directly.
+	Edit the source and run \`npm run build\`.
+{%- endcomment -%}`;
+}
+function sourcePathForComponent(component) {
+	const relativePath = relative(component.liquid.layer.path, component.liquid.path);
+	return `${component.liquid.layer.name}/${relativePath}`;
+}
+function wrapEmbedded(tag, body) {
+	return `{% ${tag} %}\n${indent(body.trimEnd())}\n{% end${tag} %}`;
+}
+/** Prepends a tab to each non-empty line. */
+function indent(text) {
+	return text.replace(/^(?=.)/gm, "	");
+}
+function rewriteRenders(source, component, lookup) {
+	return source.replace(/(\{%-?\s*(?:render|include)\s+['"])((?:@|\.)\/[^'"]+)(['"])/g, (_match, prefix, importPath, suffix) => {
+		const lookupKey = resolveImport(importPath, component).join("/");
+		const target = lookup.get(lookupKey);
+		if (!target) throw new Error(`Cannot resolve render '${importPath}' (looked up '${lookupKey}') from ${component.liquid.path}`);
+		return `${prefix}${builtNameOf(target)}${suffix}`;
+	});
+}
+function resolveImport(importPath, component) {
+	if (importPath.startsWith("@/")) return importPath.slice(2).split("/").filter(Boolean);
+	if (importPath.startsWith("./")) {
+		if (importPath.includes("../")) throw new Error(`'../' is not supported in render path: '${importPath}' (in ${component.liquid.path})`);
+		const remaining = importPath.slice(2).split("/").filter(Boolean);
+		return [...component.segments, ...remaining];
+	}
+	throw new Error(`Unexpected import path: '${importPath}'`);
+}
+async function bundleJs(tsSource) {
+	return (await bundle(tsSource.path, {
+		format: "iife",
+		platform: "browser",
+		target: "es2022",
+		absWorkingDir: tsSource.layer.path
+	})).replace(/^( {2})+/gm, (match) => "	".repeat(match.length / 2));
+}
+async function bundle(entryPoint, options) {
+	const [first] = (await build({
+		entryPoints: [entryPoint],
+		bundle: true,
+		write: false,
+		logLevel: "warning",
+		...options
+	})).outputFiles ?? [];
+	if (!first) throw new Error(`esbuild produced no output for ${entryPoint}`);
+	return first.text;
+}
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region lib/build/command.ts
+const smeltRoot$1 = dirname(dirname(fileURLToPath(import.meta.url)));
+const build$1 = defineCommand({
+	meta: {
+		name: "build",
+		description: "Compile src/ into Shopify-flat output directories."
+	},
+	async run() {
+		const count = await build$2({ layers: [{
+			name: "consumer",
+			path: process.cwd()
+		}, {
+			name: "@augeo/smelt",
+			path: smeltRoot$1
+		}] });
+		console.log(`Built ${count} component(s).`);
+	}
+});
+//#endregion
+//#region lib/dev/watch.ts
+const DEBOUNCE_MS = 100;
+async function runWatch(context) {
+	await safeBuild(context);
+	const sources = context.layers.map((layer) => join(layer.path, "src"));
+	const watcher = watch(sources, {
+		ignoreInitial: true,
+		ignored: /node_modules/
+	});
+	let pending;
+	function scheduleRebuild() {
+		if (pending) clearTimeout(pending);
+		pending = setTimeout(() => {
+			pending = void 0;
+			safeBuild(context);
+		}, DEBOUNCE_MS);
+	}
+	watcher.on("add", scheduleRebuild);
+	watcher.on("change", scheduleRebuild);
+	watcher.on("unlink", scheduleRebuild);
+	process.on("SIGINT", async () => {
+		await watcher.close();
+		process.exit(0);
+	});
+	console.log(`smelt dev — watching ${sources.length} layer(s). Ctrl-C to stop.`);
+	return new Promise(() => {});
+}
+async function safeBuild(context) {
+	const start = Date.now();
+	try {
+		const count = await build$2(context);
+		console.log(`✓ Built ${count} component(s) in ${Date.now() - start}ms`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`✗ Build failed: ${message}`);
+	}
+}
+//#endregion
+//#region lib/dev/command.ts
+const smeltRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+//#endregion
+//#region lib/cli.ts
+runMain(defineCommand({
+	meta: {
+		name: "smelt",
+		description: "Smelt build CLI."
+	},
+	subCommands: {
+		build: build$1,
+		dev: defineCommand({
+			meta: {
+				name: "dev",
+				description: "Watch src/ and rebuild on change."
+			},
+			async run() {
+				await runWatch({ layers: [{
+					name: "consumer",
+					path: process.cwd()
+				}, {
+					name: "@augeo/smelt",
+					path: smeltRoot
+				}] });
+			}
+		})
+	}
+}));
+//#endregion
+export {};

package/dist/schema.d.mts

@@ -0,0 +1,265 @@
+//#region lib/schema-block.generated.d.ts
+type Setting$1 = {
+  [k: string]: unknown | undefined;
+} & {
+  /**
+   * The type of the input or sidebar setting. This value determines the type of field that gets rendered into the editor.
+   */
+  type?: "article" | "article_list" | "blog" | "checkbox" | "collection" | "collection_list" | "color" | "color_background" | "color_palette" | "color_scheme" | "color_scheme_group" | "font_picker" | "header" | "html" | "image_picker" | "inline_richtext" | "link_list" | "liquid" | "metaobject" | "metaobject_list" | "number" | "page" | "paragraph" | "product" | "product_list" | "radio" | "range" | "richtext" | "select" | "text" | "text_alignment" | "textarea" | "url" | "video" | "video_url";
+};
+/**
+ * Settings that merchants can configure through the theme editor.
+ *
+ * @minItems 0
+ */
+type Settings$1 = Setting$1[];
+type ShopifyLiquidSectionOrBlockPresetSchema$1 = PresetWithBlocksArray$1 | PresetWithBlocksHash$1;
+type PresetWithBlocksArray$1 = PresetBase$1 & {
+  name?: unknown;
+  category?: unknown;
+  settings?: unknown;
+  blocks?: BlocksArray$1;
+};
+/**
+ * A list of child blocks that you might want to include.
+ */
+type BlocksArray$1 = CommonBlockAttributes$1[];
+type PresetWithBlocksHash$1 = PresetBase$1 & {
+  name?: unknown;
+  settings?: unknown;
+  blocks: BlocksHash$1;
+  /**
+   * The order of blocks in the preset.
+   */
+  block_order?: unknown[];
+  additionalProperties?: never;
+};
+interface ThemeBlockSchema {
+  /**
+   * The name attribute determines the block title that's shown in the theme editor.
+   */
+  name?: string;
+  settings?: Settings$1;
+  /**
+   * Theme blocks can accept other app and theme blocks as children using the blocks attribute of their schema.
+   */
+  blocks?: {
+    [k: string]: unknown | undefined;
+  }[];
+  /**
+   * Presets are default configurations of blocks that enable merchants to easily add a block to a JSON template through the theme editor.
+   */
+  presets?: ShopifyLiquidSectionOrBlockPresetSchema$1[];
+  /**
+   * The HTML element that is used to wrap the rendered block. Accepts any string up to 50 characters. Can be used to render custom HTML elements. Use null to render without a wrapping element.
+   */
+  tag?: string | null;
+  /**
+   * When Shopify renders a block, it's wrapped in an HTML element with the shopify-block class. You can append other classes by using the class attribute.
+   */
+  class?: string;
+}
+interface PresetBase$1 {
+  /**
+   * The preset name, which will show in the 'Add section' or 'Add block' picker of the theme editor.
+   */
+  name: string;
+  /**
+   * The category of the preset, which will show in the 'Add section' or 'Add block' picker of the theme editor.
+   */
+  category?: string;
+  settings?: DefaultSettingValues$1;
+}
+/**
+ * A list of default values for any settings that you might want to populate. Each entry should include the setting name and the value.
+ */
+interface DefaultSettingValues$1 {
+  [k: string]: (number | boolean | string | string[]) | undefined;
+}
+interface CommonBlockAttributes$1 {
+  /**
+   * The block type.
+   */
+  type: string;
+  /**
+   * The block name.
+   */
+  name?: string;
+  settings?: DefaultSettingValues$1;
+  /**
+   * If the block is rendered statically or not.
+   */
+  static?: boolean;
+}
+/**
+ * A list of child blocks that you might want to include.
+ */
+interface BlocksHash$1 {
+  [k: string]: CommonBlockAttributes$1 | undefined;
+}
+//#endregion
+//#region lib/schema-section.generated.d.ts
+type Setting = {
+  [k: string]: unknown | undefined;
+} & {
+  /**
+   * The type of the input or sidebar setting. This value determines the type of field that gets rendered into the editor.
+   */
+  type?: "article" | "article_list" | "blog" | "checkbox" | "collection" | "collection_list" | "color" | "color_background" | "color_palette" | "color_scheme" | "color_scheme_group" | "font_picker" | "header" | "html" | "image_picker" | "inline_richtext" | "link_list" | "liquid" | "metaobject" | "metaobject_list" | "number" | "page" | "paragraph" | "product" | "product_list" | "radio" | "range" | "richtext" | "select" | "text" | "text_alignment" | "textarea" | "url" | "video" | "video_url";
+};
+/**
+ * Settings that merchants can configure through the theme editor.
+ *
+ * @minItems 0
+ */
+type Settings = Setting[];
+type ShopifyLiquidSectionOrBlockPresetSchema = PresetWithBlocksArray | PresetWithBlocksHash;
+type PresetWithBlocksArray = PresetBase & {
+  name?: unknown;
+  category?: unknown;
+  settings?: unknown;
+  blocks?: BlocksArray;
+};
+/**
+ * A list of child blocks that you might want to include.
+ */
+type BlocksArray = CommonBlockAttributes[];
+type PresetWithBlocksHash = PresetBase & {
+  name?: unknown;
+  settings?: unknown;
+  blocks: BlocksHash;
+  /**
+   * The order of blocks in the preset.
+   */
+  block_order?: unknown[];
+  additionalProperties?: never;
+};
+interface SectionSchema {
+  /**
+   * The name attribute determines the section title that is shown in the theme editor.
+   */
+  name?: string;
+  /**
+   * The HTML element that is used to wrap the section.
+   */
+  tag?: "article" | "aside" | "div" | "footer" | "header" | "section";
+  /**
+   * Additional CSS class for the section.
+   */
+  class?: string;
+  /**
+   * The number of times a section can be added to a template or section group.
+   */
+  limit?: number;
+  settings?: Settings;
+  /**
+   * There's a limit of 50 blocks per section. You can specify a lower limit with the max_blocks attribute
+   */
+  max_blocks?: number;
+  /**
+   * Blocks are reusable modules of content that can be added, removed, and reordered within a section.
+   */
+  blocks?: {
+    [k: string]: unknown | undefined;
+  }[];
+  /**
+   * Presets are default configurations of sections that enable users to easily add a section to a JSON template through the theme editor.
+   */
+  presets?: ShopifyLiquidSectionOrBlockPresetSchema[];
+  /**
+   * Default configuration for statically rendered sections.
+   */
+  default?: {
+    settings?: DefaultSettingValues;
+    /**
+     * Default blocks configurations to ship with this default.
+     */
+    blocks?: {
+      /**
+       * The block type.
+       */
+      type: string;
+      settings?: DefaultSettingValues;
+    }[];
+  };
+  /**
+   * Sections can provide their own set of translated strings through the locales object. This is separate from the locales directory of the theme, which makes it a useful feature for sections that are meant to be installed on multiple themes or shops.
+   */
+  locales?: {
+    [k: string]: {
+      [k: string]: string | undefined;
+    } | undefined;
+  };
+  enabled_on?: SectionToggle;
+  disabled_on?: SectionToggle1;
+}
+interface PresetBase {
+  /**
+   * The preset name, which will show in the 'Add section' or 'Add block' picker of the theme editor.
+   */
+  name: string;
+  /**
+   * The category of the preset, which will show in the 'Add section' or 'Add block' picker of the theme editor.
+   */
+  category?: string;
+  settings?: DefaultSettingValues;
+}
+/**
+ * A list of default values for any settings that you might want to populate. Each entry should include the setting name and the value.
+ */
+interface DefaultSettingValues {
+  [k: string]: (number | boolean | string | string[]) | undefined;
+}
+interface CommonBlockAttributes {
+  /**
+   * The block type.
+   */
+  type: string;
+  /**
+   * The block name.
+   */
+  name?: string;
+  settings?: DefaultSettingValues;
+  /**
+   * If the block is rendered statically or not.
+   */
+  static?: boolean;
+}
+/**
+ * A list of child blocks that you might want to include.
+ */
+interface BlocksHash {
+  [k: string]: CommonBlockAttributes | undefined;
+}
+/**
+ * Restrict the section to certain template page types and section group types.
+ */
+interface SectionToggle {
+  templates?: ("*" | "404" | "article" | "blog" | "captcha" | "cart" | "collection" | "customers/account" | "customers/activate_account" | "customers/addresses" | "customers/login" | "customers/order" | "customers/register" | "customers/reset_password" | "gift_card" | "index" | "list-collections" | "metaobject" | "page" | "password" | "policy" | "product" | "search")[];
+  groups?: string[];
+}
+/**
+ * Prevent the section from being used on certain template page types and section group types.
+ */
+interface SectionToggle1 {
+  templates?: ("*" | "404" | "article" | "blog" | "captcha" | "cart" | "collection" | "customers/account" | "customers/activate_account" | "customers/addresses" | "customers/login" | "customers/order" | "customers/register" | "customers/reset_password" | "gift_card" | "index" | "list-collections" | "metaobject" | "page" | "password" | "policy" | "product" | "search")[];
+  groups?: string[];
+}
+//#endregion
+//#region lib/schema.d.ts
+/**
+ * Identity helper for authoring a Shopify section schema. The `const T`
+ * parameter preserves literal types so the schema author gets autocomplete
+ * for setting `type` values, `id`s, etc.
+ *
+ * Use in `<name>.schema.ts` files under `src/sections/`.
+ */
+declare function defineSchemaSection<const T extends SectionSchema>(schema: T): T;
+/**
+ * Identity helper for authoring a Shopify theme-block schema.
+ *
+ * Use in `<name>.schema.ts` files under `src/blocks/`.
+ */
+declare function defineSchemaBlock<const T extends ThemeBlockSchema>(schema: T): T;
+//#endregion
+export { type SectionSchema, type ThemeBlockSchema, defineSchemaBlock, defineSchemaSection };

package/dist/schema.mjs

@@ -0,0 +1,21 @@
+//#region lib/schema.ts
+/**
+* Identity helper for authoring a Shopify section schema. The `const T`
+* parameter preserves literal types so the schema author gets autocomplete
+* for setting `type` values, `id`s, etc.
+*
+* Use in `<name>.schema.ts` files under `src/sections/`.
+*/
+function defineSchemaSection(schema) {
+	return schema;
+}
+/**
+* Identity helper for authoring a Shopify theme-block schema.
+*
+* Use in `<name>.schema.ts` files under `src/blocks/`.
+*/
+function defineSchemaBlock(schema) {
+	return schema;
+}
+//#endregion
+export { defineSchemaBlock, defineSchemaSection };