@shop-on/theme-contract 0.5.0 → 0.6.0

package/dist/template-limits.js

@@ -0,0 +1,71 @@
+//#region src/template-limits.ts
+const MAX_SECTIONS_PER_TEMPLATE = 25;
+const MAX_BLOCKS_PER_TEMPLATE = 1250;
+const MAX_BLOCK_NESTING_DEPTH = 8;
+/** One template or section group, as compact JSON. The largest a shipped
+*  theme has is ~60 KB; a template at the block cap is ~250–500 KB. */
+const MAX_ENTRY_BYTES = 524288;
+const isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+/** The blocks under `node` (a section or a block), at every depth. */
+function countNestedBlocks(node) {
+	if (!isObject(node) || !isObject(node.blocks)) return 0;
+	let total = 0;
+	for (const child of Object.values(node.blocks)) total += 1 + countNestedBlocks(child);
+	return total;
+}
+/** A template's or section group's sections (its `order`, as the editor
+*  counts them) and its blocks across every section. Both are
+*  `{sections, order}` documents. */
+function templateCounts(entry) {
+	if (!isObject(entry)) return {
+		sections: 0,
+		blocks: 0
+	};
+	const sections = Array.isArray(entry.order) ? entry.order.length : 0;
+	let blocks = 0;
+	if (isObject(entry.sections)) for (const section of Object.values(entry.sections)) blocks += countNestedBlocks(section);
+	return {
+		sections,
+		blocks
+	};
+}
+/** Levels of blocks under `node`: 0 for none, 1 for blocks with no children. */
+function blockLevels(node) {
+	if (!isObject(node) || !isObject(node.blocks)) return 0;
+	let deepest = 0;
+	for (const child of Object.values(node.blocks)) deepest = Math.max(deepest, blockLevels(child));
+	return Object.keys(node.blocks).length > 0 ? 1 + deepest : 0;
+}
+/** The deepest block level in a template or section group, as the editor
+*  counts it against `MAX_BLOCK_NESTING_DEPTH`: a block directly in a section
+*  is level 1, a section with no blocks is 0. */
+function maxBlockDepth(entry) {
+	if (!isObject(entry) || !isObject(entry.sections)) return 0;
+	let deepest = 0;
+	for (const section of Object.values(entry.sections)) deepest = Math.max(deepest, blockLevels(section));
+	return deepest;
+}
+function countBlocksInBlock(block) {
+	return 1 + countNestedBlocks(block);
+}
+/** 1-indexed depth of the deepest descendant within `block` (the block itself
+*  counts as 1). Prices a subtree about to be inserted against the nesting cap. */
+function maxDepthOfBlock(block) {
+	let deepest = 1;
+	if (isObject(block.blocks)) {
+		for (const child of Object.values(block.blocks)) if (isObject(child)) deepest = Math.max(deepest, 1 + maxDepthOfBlock(child));
+	}
+	return deepest;
+}
+function maxDepthOfBlockSchema(blockType, blockSchemas, remaining = 9) {
+	if (remaining <= 1) return 1;
+	const schema = blockSchemas.find((b) => b.type === blockType);
+	let deepest = 1;
+	for (const child of schema?.blocks ?? []) {
+		if (!child.static) continue;
+		deepest = Math.max(deepest, 1 + maxDepthOfBlockSchema(child.type, blockSchemas, remaining - 1));
+	}
+	return deepest;
+}
+//#endregion
+export { MAX_BLOCKS_PER_TEMPLATE, MAX_BLOCK_NESTING_DEPTH, MAX_ENTRY_BYTES, MAX_SECTIONS_PER_TEMPLATE, countBlocksInBlock, countNestedBlocks, maxBlockDepth, maxDepthOfBlock, maxDepthOfBlockSchema, templateCounts };

package/dist/video-url.d.ts

@@ -0,0 +1,10 @@
+//#region src/video-url.d.ts
+export type VideoProvider = "youtube" | "vimeo";
+export declare function parseVideoUrl(url: string): {
+  provider: VideoProvider;
+  id: string;
+} | null;
+/** Whether the video field accepts the URL — a YouTube/Vimeo link within
+ *  `accept`. Anything else it flags as unsupported. */
+export declare function isAcceptedVideoUrl(url: string, accept?: readonly string[]): boolean;
+//#endregion

package/dist/video-url.js

@@ -0,0 +1,36 @@
+//#region src/video-url.ts
+function parseVideoUrl(url) {
+	try {
+		const u = new URL(url);
+		if (u.hostname.includes("youtube.com") || u.hostname.includes("youtube-nocookie.com")) {
+			const id = u.searchParams.get("v") ?? u.pathname.split("/embed/")[1] ?? u.pathname.split("/shorts/")[1];
+			return id ? {
+				provider: "youtube",
+				id
+			} : null;
+		}
+		if (u.hostname === "youtu.be") {
+			const id = u.pathname.slice(1);
+			return id ? {
+				provider: "youtube",
+				id
+			} : null;
+		}
+		if (u.hostname.includes("vimeo.com")) {
+			const id = u.pathname.match(/\/(?:video\/)?(\d+)/)?.[1];
+			return id ? {
+				provider: "vimeo",
+				id
+			} : null;
+		}
+	} catch {}
+	return null;
+}
+/** Whether the video field accepts the URL — a YouTube/Vimeo link within
+*  `accept`. Anything else it flags as unsupported. */
+function isAcceptedVideoUrl(url, accept) {
+	const parsed = parseVideoUrl(url);
+	return !!parsed && (!accept || accept.includes(parsed.provider));
+}
+//#endregion
+export { isAcceptedVideoUrl, parseVideoUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shop-on/theme-contract",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "license": "SEE LICENSE IN dist/LICENSE.md",
   "files": [
     "dist"
@@ -9,8 +9,13 @@
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.js",
+    "./ai-files": "./dist/ai-files.js",
+    "./closest-scope": "./dist/closest-scope.js",
+    "./editor-tools": "./dist/editor-tools/index.js",
+    "./ops": "./dist/ops.js",
     "./preset-listing": "./dist/preset-listing.js",
     "./preset-materializer": "./dist/preset-materializer.js",
+    "./store-path": "./dist/store-path.js",
     "./package.json": "./package.json"
   },
   "dependencies": {
@@ -18,11 +23,13 @@
   },
   "devDependencies": {
     "@types/node": "26.6.5",
+    "tsx": "^4.23.15",
     "typescript": "7.0.2",
     "vitest": "5.0.5"
   },
   "scripts": {
     "check-types": "tsc --noEmit",
+    "gen:editor-tools": "tsx scripts/gen-editor-tools.ts",
     "test": "vitest run --maxWorkers=2"
   }
 }