@questpie/admin 2.0.0 → 3.0.0

package/dist/server/patch.mjs

@@ -1,1062 +0,0 @@
-import { BlockBuilder } from "./block/block-builder.mjs";
-import { createBlocksPrefetchHook } from "./block/prefetch.mjs";
-import { CollectionBuilder, GlobalBuilder, QuestpieBuilder, createFieldBuilder, createFieldDefinition } from "questpie";
-
-//#region src/server/patch.ts
-/**
-* Runtime Monkey Patching for Admin Builder Methods
-*
-* This module patches QuestpieBuilder, CollectionBuilder, and GlobalBuilder
-* with admin-specific methods when adminModule is used.
-*
-* The patches add these methods:
-* - QuestpieBuilder: listView(), editView(), component(), listViews(), editViews(), components()
-* - CollectionBuilder: admin(), list(), form(), preview()
-* - GlobalBuilder: admin(), form()
-*
-* Type augmentation is handled by ./augmentation.ts which extends the builder types.
-*
-* @internal This module is automatically imported by adminModule.
-*/
-let patchesApplied = false;
-/**
-* Resolve registry source state.
-*
-* - Collection/Global builders: registry lives on `state["~questpieApp"].state`
-* - QuestpieBuilder: registry lives on `state`
-*/
-function getRegistrySourceState(builderState) {
-	const questpieApp = builderState["~questpieApp"];
-	if (questpieApp?.state && typeof questpieApp.state === "object") return questpieApp.state;
-	return builderState;
-}
-/**
-* Resolve registered component names from builder state.
-*/
-function getRegisteredComponentNames(builderState) {
-	const components = getRegistrySourceState(builderState).components;
-	if (!components || typeof components !== "object") return [];
-	return Object.keys(components);
-}
-/**
-* Normalize component props into a serializable object.
-*
-* Backward compatibility:
-* - `c.icon("ph:users")` => `{ name: "ph:users" }`
-*/
-function normalizeComponentProps(componentType, props) {
-	if (componentType === "icon" && typeof props === "string") return { name: props };
-	if (props === null || props === void 0) return {};
-	if (typeof props === "object") return props;
-	return { value: props };
-}
-/**
-* Create a component proxy for registered component references.
-* Used in admin config functions (`.admin()`, `.actions()`, `.dashboard()`, `.sidebar()`).
-*
-* @example
-* ```ts
-* .admin(({ c }) => ({
-*   icon: c.icon("ph:users"),
-*   badge: c.badge({ text: "New", color: "green" }),
-* }))
-* ```
-*/
-function createComponentProxy(builderState) {
-	const componentNames = getRegisteredComponentNames(builderState);
-	const registeredComponentSet = new Set(componentNames);
-	return new Proxy({}, {
-		get: (_target, prop) => {
-			if (typeof prop !== "string") return;
-			if (prop === "then") return;
-			if (registeredComponentSet.size === 0) throw new Error("No components registered. Register components via .components() or use q.use(adminModule) defaults.");
-			if (!registeredComponentSet.has(prop)) throw new Error(`Unknown component "${prop}". Register it via .components(). Available components: ${[...registeredComponentSet].sort().join(", ")}`);
-			return (props) => ({
-				type: prop,
-				props: normalizeComponentProps(prop, props)
-			});
-		},
-		has: (_target, prop) => {
-			if (typeof prop !== "string") return false;
-			return registeredComponentSet.has(prop);
-		},
-		ownKeys: () => [...registeredComponentSet],
-		getOwnPropertyDescriptor: (_target, prop) => {
-			if (typeof prop !== "string") return;
-			if (!registeredComponentSet.has(prop)) return;
-			return {
-				configurable: true,
-				enumerable: true,
-				writable: false,
-				value: (props) => ({
-					type: prop,
-					props: normalizeComponentProps(prop, props)
-				})
-			};
-		}
-	});
-}
-/**
-* Create a field proxy for referencing collection fields.
-* Returns field names as strings for config objects.
-*
-* @example
-* ```ts
-* .list(({ f }) => ({
-*   columns: [f.title, f.author, f.createdAt],
-* }))
-* ```
-*/
-function createFieldProxy(fieldNames) {
-	return new Proxy({}, {
-		get: (_target, prop) => prop,
-		has: (_target, prop) => fieldNames.includes(prop),
-		ownKeys: () => fieldNames,
-		getOwnPropertyDescriptor: (_target, prop) => {
-			if (fieldNames.includes(prop)) return {
-				configurable: true,
-				enumerable: true,
-				value: prop
-			};
-		}
-	});
-}
-/**
-* Create a view proxy for defining view configurations.
-*
-* If the builder is bound to a Questpie app with registered views
-* (`.listViews()` / `.editViews()`), the proxy only allows those names.
-* If no registry is available (standalone builders), any view name is allowed.
-*
-* @example
-* ```ts
-* .list(({ v }) => v.table({
-*   columns: [...],
-*   defaultSort: { field: "createdAt", direction: "desc" },
-* }))
-* ```
-*/
-function createViewProxy(kind, registeredViews = []) {
-	const registeredViewSet = new Set(registeredViews);
-	const hasRegistry = registeredViewSet.size > 0;
-	return new Proxy({}, {
-		get: (_target, prop) => {
-			if (typeof prop !== "string") return;
-			if (prop === "then") return;
-			const registerMethod = kind === "list" ? "listViews" : "editViews";
-			if (!hasRegistry) throw new Error(`No ${kind} views registered. Register them via .${registerMethod}() or use q.use(adminModule) defaults.`);
-			if (!registeredViewSet.has(prop)) {
-				const available = [...registeredViewSet].sort().join(", ");
-				throw new Error(`Unknown ${kind} view "${prop}". Register it via .${registerMethod}(). Available ${kind} views: ${available || "(none)"}`);
-			}
-			return (config = {}) => ({
-				view: prop,
-				...config
-			});
-		},
-		has: (_target, prop) => {
-			if (typeof prop !== "string") return false;
-			return hasRegistry && registeredViewSet.has(prop);
-		},
-		ownKeys: () => hasRegistry ? [...registeredViewSet] : [],
-		getOwnPropertyDescriptor: (_target, prop) => {
-			if (typeof prop !== "string") return;
-			if (hasRegistry && !registeredViewSet.has(prop)) return;
-			return {
-				configurable: true,
-				enumerable: hasRegistry,
-				writable: false,
-				value: (config = {}) => ({
-					view: prop,
-					...config
-				})
-			};
-		}
-	});
-}
-/**
-* Resolve registered view names from a builder's parent Questpie app state.
-*/
-function getRegisteredViewNames(builderState, kind) {
-	const views = getRegistrySourceState(builderState)[kind === "list" ? "listViews" : "editViews"];
-	if (!views || typeof views !== "object") return [];
-	return Object.keys(views);
-}
-/**
-* Validate a selected view name against registered view names.
-*/
-function ensureRegisteredView(kind, viewName, registeredViews) {
-	if (registeredViews.length === 0 || typeof viewName !== "string") return;
-	if (registeredViews.includes(viewName)) return;
-	const registerMethod = kind === "list" ? "listViews" : "editViews";
-	throw new Error(`Unknown ${kind} view "${viewName}". Register it via .${registerMethod}(). Available ${kind} views: ${registeredViews.sort().join(", ")}`);
-}
-/**
-* Create an action proxy for referencing built-in and custom actions.
-*
-* @example
-* ```ts
-* .list(({ a }) => ({
-*   actions: {
-*     header: { primary: [a.create] },
-*     bulk: [a.delete, a.export],
-*   },
-* }))
-* ```
-*/
-function createActionProxy() {
-	return {
-		create: "create",
-		save: "save",
-		delete: "delete",
-		deleteMany: "deleteMany",
-		duplicate: "duplicate",
-		export: "export",
-		custom: (name, config) => ({
-			type: name,
-			config
-		})
-	};
-}
-/**
-* Create action helpers for dashboard header actions.
-*/
-function createDashboardActionProxy() {
-	const toCollectionCreatePath = (collection) => `/admin/collections/${collection}/create`;
-	const toGlobalPath = (global) => `/admin/globals/${global}`;
-	return {
-		action: (config) => config,
-		link: (config) => config,
-		create: ({ collection, ...config }) => ({
-			...config,
-			href: toCollectionCreatePath(collection)
-		}),
-		global: ({ global, ...config }) => ({
-			...config,
-			href: toGlobalPath(global)
-		})
-	};
-}
-/**
-* Create an actions config context for the .actions() method.
-* Provides builders for both built-in and custom actions.
-*
-* @example
-* ```ts
-* .actions(({ a, c, f }) => ({
-*   builtin: [a.create(), a.delete(), a.deleteMany()],
-*   custom: [
-*     a.action({
-*       id: "send-email",
-*       label: { en: "Send Email" },
-*       icon: c.icon("ph:envelope"),
-*       form: {
-*         title: { en: "Send Email" },
-*         fields: {
-*           subject: f.text({ label: { en: "Subject" }, required: true }),
-*           message: f.textarea({ label: { en: "Message" } }),
-*         },
-*       },
-*       handler: async ({ data }) => {
-*         return { type: "success", toast: { message: "Email sent!" } };
-*       },
-*     }),
-*   ],
-* }))
-* ```
-*/
-function createActionsConfigContext(builderState, fieldRegistry) {
-	const fieldProxy = new Proxy({}, { get: (_target, prop) => {
-		const factory = fieldRegistry[prop];
-		if (!factory) {
-			const available = Object.keys(fieldRegistry).sort();
-			if (available.length === 0) throw new Error("No field types registered for action form fields. Register fields on the Questpie builder before using .actions().");
-			throw new Error(`Unknown field type: "${prop}". Available types: ${available.join(", ")}`);
-		}
-		return (config) => factory(config);
-	} });
-	return {
-		a: {
-			create: () => "create",
-			save: () => "save",
-			delete: () => "delete",
-			deleteMany: () => "deleteMany",
-			duplicate: () => "duplicate",
-			action: (def) => ({
-				...def,
-				scope: def.scope ?? "single"
-			}),
-			bulkAction: (def) => ({
-				...def,
-				scope: "bulk"
-			}),
-			headerAction: (def) => ({
-				...def,
-				scope: "header"
-			})
-		},
-		c: createComponentProxy(builderState),
-		f: fieldProxy
-	};
-}
-/**
-* Patch QuestpieBuilder with admin methods
-*/
-function patchQuestpieBuilder() {
-	const proto = QuestpieBuilder.prototype;
-	/**
-	* Create a list view definition.
-	* Returns a definition object for use in .listViews()
-	*/
-	proto.listView = (name, config = {}) => ({
-		type: "listView",
-		name,
-		...config
-	});
-	/**
-	* Create an edit view definition.
-	* Returns a definition object for use in .editViews()
-	*/
-	proto.editView = (name, config = {}) => ({
-		type: "editView",
-		name,
-		...config
-	});
-	/**
-	* Create a component definition.
-	* Returns a definition object for use in .components()
-	*/
-	proto.component = (name, config = {}) => ({
-		type: "component",
-		name,
-		...config
-	});
-	/**
-	* Register list views on the builder.
-	* Merges with existing list views.
-	*/
-	proto.listViews = function(views) {
-		return new QuestpieBuilder({
-			...this.state,
-			listViews: {
-				...this.state.listViews || {},
-				...views
-			}
-		});
-	};
-	/**
-	* Register edit views on the builder.
-	* Merges with existing edit views.
-	*/
-	proto.editViews = function(views) {
-		return new QuestpieBuilder({
-			...this.state,
-			editViews: {
-				...this.state.editViews || {},
-				...views
-			}
-		});
-	};
-	/**
-	* Register components on the builder.
-	* Merges with existing components.
-	*/
-	proto.components = function(components) {
-		return new QuestpieBuilder({
-			...this.state,
-			components: {
-				...this.state.components || {},
-				...components
-			}
-		});
-	};
-	/**
-	* Register block types for the visual block editor.
-	* Blocks are built and stored on the state for use by blocks fields.
-	*
-	* Accepts three input shapes per block:
-	* - **Server BlockBuilder** (legacy): `block("hero").fields(...).prefetch(...)`
-	* - **Client BlockDefinition**: `heroBlock` (auto-expansion handles relations)
-	* - **With manual prefetch**: `{ block: heroBlock, prefetch: async ({ values, ctx }) => ({...}) }`
-	*
-	* Relation and upload fields are auto-expanded in the afterRead hook.
-	* Use the `{ block, prefetch }` shape for custom data that can't be auto-expanded.
-	*
-	* @example
-	* ```ts
-	* import { heroBlock, textBlock } from "./blocks";
-	*
-	* const cms = q({ name: "my-app" })
-	*   .use(adminModule)
-	*   .blocks({
-	*     // Simple block - relations auto-expanded
-	*     hero: heroBlock,
-	*     text: textBlock,
-	*     // Block with manual prefetch for custom data
-	*     featuredPosts: {
-	*       block: featuredPostsBlock,
-	*       prefetch: async ({ values, ctx }) => {
-	*         const posts = await ctx.app.api.collections.posts.find({ limit: values.count });
-	*         return { posts: posts.docs };
-	*       },
-	*     },
-	*   })
-	*   .build({ ... });
-	* ```
-	*/
-	proto.blocks = function(blocks) {
-		const builtBlocks = {};
-		for (const [name, blockInput] of Object.entries(blocks)) {
-			if (typeof blockInput.build === "function" && typeof blockInput.state?.name === "string") {
-				const blockBuilder = blockInput;
-				const state = blockBuilder.state;
-				if (state._fieldsFactory && this.state.fields) {
-					const fieldProxy = createFieldBuilder(this.state.fields);
-					state.fields = state._fieldsFactory(fieldProxy);
-					delete state._fieldsFactory;
-				}
-				builtBlocks[name] = blockBuilder.build();
-				continue;
-			}
-			let blockDef;
-			let prefetchFn;
-			if ("block" in blockInput && typeof blockInput.block === "object" && blockInput.block !== null && "name" in blockInput.block) {
-				const wrapper = blockInput;
-				blockDef = wrapper.block;
-				prefetchFn = wrapper.prefetch;
-			} else blockDef = blockInput;
-			builtBlocks[name] = {
-				name: blockDef.name || name,
-				state: {
-					...blockDef.state,
-					prefetch: prefetchFn || blockDef.state.prefetch
-				},
-				getFieldMetadata: blockDef.getFieldMetadata.bind(blockDef),
-				executePrefetch: async (values, ctx) => {
-					if (prefetchFn) return prefetchFn({
-						values,
-						ctx
-					});
-					return blockDef.executePrefetch(values, ctx);
-				}
-			};
-		}
-		return new QuestpieBuilder({
-			...this.state,
-			blocks: {
-				...this.state.blocks || {},
-				...builtBlocks
-			}
-		});
-	};
-	/**
-	* Create a block builder bound to this Questpie builder.
-	* The block has access to all registered field types from `.fields()`.
-	*
-	* @example
-	* ```ts
-	* const qb = q.use(adminModule);
-	*
-	* const heroBlock = qb.block("hero")
-	*   .label({ en: "Hero Section" })
-	*   .icon("ph:image")
-	*   .fields((f) => ({
-	*     title: f.text({ required: true }),  // ✅ typed from builder's field registry
-	*     subtitle: f.text(),
-	*   }));
-	*
-	* const cms = qb
-	*   .blocks({ hero: heroBlock })
-	*   .build({ ... });
-	* ```
-	*/
-	proto.block = function(name) {
-		const registeredComponents = getRegisteredComponentNames(this.state);
-		return new BlockBuilder({
-			name,
-			"~components": registeredComponents
-		});
-	};
-	/**
-	* Configure the admin dashboard.
-	* Widgets that need data (stats, chart, recentItems) are executed on server.
-	*
-	* @example
-	* ```ts
-	* .dashboard(({ d, c, a }) => d.dashboard({
-	*   title: { en: "Dashboard" },
-	*   actions: [
-	*     a.create({
-	*       id: "new-user",
-	*       collection: "users",
-	*       label: { en: "New User" },
-	*       icon: c.icon("ph:user-plus"),
-	*     }),
-	*   ],
-	*   items: [
-	*     d.section({
-	*       label: { en: "Overview" },
-	*       items: [
-	*         d.stats({ collection: "users", label: { en: "Total Users" } }),
-	*       ],
-	*     }),
-	*   ],
-	* }))
-	* ```
-	*/
-	proto.dashboard = function(configFn) {
-		const dashboard = configFn({
-			a: createDashboardActionProxy(),
-			d: {
-				dashboard: (config) => config,
-				section: (config) => ({
-					type: "section",
-					...config
-				}),
-				tabs: (config) => ({
-					type: "tabs",
-					...config
-				}),
-				stats: (config) => ({
-					type: "stats",
-					...config
-				}),
-				chart: (config) => ({
-					type: "chart",
-					...config
-				}),
-				recentItems: (config) => ({
-					type: "recentItems",
-					...config
-				}),
-				quickActions: (config) => ({
-					type: "quickActions",
-					...config
-				}),
-				custom: (config) => ({
-					type: "custom",
-					...config
-				}),
-				value: (config) => ({
-					type: "value",
-					...config
-				}),
-				table: (config) => ({
-					type: "table",
-					...config
-				}),
-				timeline: (config) => ({
-					type: "timeline",
-					...config
-				}),
-				progress: (config) => ({
-					type: "progress",
-					...config
-				})
-			},
-			c: createComponentProxy(this.state)
-		});
-		return new QuestpieBuilder({
-			...this.state,
-			dashboard
-		});
-	};
-	/**
-	* Configure the admin sidebar.
-	* Sections can contain collections, globals, pages, links, and dividers.
-	*
-	* @example
-	* ```ts
-	* .sidebar(({ s, c }) => s.sidebar({
-	*   sections: [
-	*     s.section({
-	*       id: "content",
-	*       title: { en: "Content" },
-	*       icon: c.icon("ph:files"),
-	*       items: [
-	*         { type: "collection", collection: "posts" },
-	*         { type: "collection", collection: "pages" },
-	*       ],
-	*     }),
-	*   ],
-	* }))
-	* ```
-	*/
-	proto.sidebar = function(configFn) {
-		const sidebar = configFn({
-			s: {
-				sidebar: (config) => config,
-				section: (config) => ({
-					items: [],
-					...config
-				})
-			},
-			c: createComponentProxy(this.state)
-		});
-		return new QuestpieBuilder({
-			...this.state,
-			sidebar
-		});
-	};
-	proto.branding = function(config) {
-		return new QuestpieBuilder({
-			...this.state,
-			branding: config
-		});
-	};
-	/**
-	* Configure admin UI locales (separate from content locales).
-	*
-	* UI locales control the admin interface language.
-	* Content locales (set via .locale()) control which languages content can be edited in.
-	* These don't need to match - you can have 10 content languages but only 2 UI languages.
-	*
-	* @example
-	* ```ts
-	* const cms = q({ name: "my-app" })
-	*   .use(adminModule)
-	*   // Content can be in many languages
-	*   .locale({
-	*     locales: [{ code: "en" }, { code: "sk" }, { code: "de" }, ...],
-	*     defaultLocale: "en",
-	*   })
-	*   // But admin UI only in 2 languages
-	*   .adminLocale({
-	*     locales: ["en", "sk"],
-	*     defaultLocale: "en",
-	*   })
-	*   .build({ ... });
-	* ```
-	*/
-	proto.adminLocale = function(config) {
-		return new QuestpieBuilder({
-			...this.state,
-			adminLocale: config
-		});
-	};
-	/**
-	* Patch .use() to propagate admin extension properties.
-	*
-	* The core .use() only merges hardcoded properties (collections, globals,
-	* jobs, emailTemplates, fields, auth, locale, migrations, translations).
-	* Admin extensions (sidebar, dashboard, branding, listViews, editViews,
-	* components, blocks, adminLocale) would be lost without this patch.
-	*/
-	const originalUse = proto.use;
-	proto.use = function(other) {
-		const result = originalUse.call(this, other);
-		const otherState = other.state;
-		const coreKeys = new Set([
-			"name",
-			"collections",
-			"globals",
-			"jobs",
-			"emailTemplates",
-			"fields",
-			"auth",
-			"locale",
-			"migrations",
-			"translations",
-			"~messageKeys"
-		]);
-		const extensionState = {};
-		for (const key of Object.keys(this.state)) if (!coreKeys.has(key) && this.state[key] !== void 0) extensionState[key] = this.state[key];
-		for (const key of Object.keys(otherState)) if (!coreKeys.has(key) && otherState[key] !== void 0) extensionState[key] = otherState[key];
-		if (Object.keys(extensionState).length > 0) return new QuestpieBuilder({
-			...result.state,
-			...extensionState
-		});
-		return result;
-	};
-	/**
-	* Patch .build() to inject block definitions into blocks-type field configs
-	* before the real build, and to store admin extension state on the built
-	* Questpie instance so getAdminConfig can read sidebar/dashboard/etc.
-	*/
-	const originalBuild = proto.build;
-	proto.build = function(...args) {
-		const blockDefs = this.state.blocks;
-		if (blockDefs && Object.keys(blockDefs).length > 0) {
-			injectBlockDefinitions(this.state, blockDefs);
-			injectBlocksPrefetchHooks(this.state);
-			validateAllowedBlocks(this.state, blockDefs);
-		}
-		const instance = originalBuild.apply(this, args);
-		const extensionKeys = [
-			"sidebar",
-			"dashboard",
-			"branding",
-			"blocks",
-			"listViews",
-			"editViews",
-			"components",
-			"adminLocale"
-		];
-		const adminState = {};
-		for (const key of extensionKeys) if (this.state[key] !== void 0) adminState[key] = this.state[key];
-		instance.state = adminState;
-		return instance;
-	};
-}
-/**
-* Inject block definitions into all blocks-type field configs
-* in collections and globals. Enables per-block field validation.
-* @internal
-*/
-function injectBlockDefinitions(state, blockDefs) {
-	if (state.collections) for (const collection of Object.values(state.collections)) {
-		const fields = collection?.state?.fields;
-		if (!fields) continue;
-		for (const fieldDef of Object.values(fields)) if (fieldDef?.state?.config?.type === "blocks") fieldDef.state.config._blockDefinitions = blockDefs;
-	}
-	if (state.globals) for (const global of Object.values(state.globals)) {
-		const fields = global?.state?.fields;
-		if (!fields) continue;
-		for (const fieldDef of Object.values(fields)) if (fieldDef?.state?.config?.type === "blocks") fieldDef.state.config._blockDefinitions = blockDefs;
-	}
-}
-/**
-* Auto-inject afterRead hook for blocks prefetch on collections/globals
-* that have at least one blocks-type field.
-*
-* This eliminates the need for manually adding:
-* ```ts
-* .hooks({ afterRead: createBlocksPrefetchHook() })
-* ```
-* @internal
-*/
-function injectBlocksPrefetchHooks(state) {
-	const prefetchHook = createBlocksPrefetchHook();
-	const injectIfHasBlocksField = (entity, name) => {
-		const fieldDefinitions = entity?.state?.fieldDefinitions;
-		if (!fieldDefinitions) return;
-		if (!Object.values(fieldDefinitions).some((fieldDef) => fieldDef?.state?.type === "blocks")) return;
-		if (!entity.state.hooks) entity.state.hooks = {};
-		const existing = entity.state.hooks.afterRead;
-		if (!existing) entity.state.hooks.afterRead = prefetchHook;
-		else {
-			const existingArray = Array.isArray(existing) ? existing : [existing];
-			entity.state.hooks.afterRead = [...existingArray, prefetchHook];
-		}
-	};
-	if (state.collections) for (const [name, collection] of Object.entries(state.collections)) injectIfHasBlocksField(collection, name);
-	if (state.globals) for (const [name, global] of Object.entries(state.globals)) injectIfHasBlocksField(global, name);
-}
-/**
-* Validate that all `allowedBlocks` entries reference registered block types.
-* Logs warnings in development for unknown block types.
-* @internal
-*/
-function validateAllowedBlocks(state, blockDefs) {
-	const registeredNames = new Set(Object.keys(blockDefs));
-	const checkFields = (fields, context) => {
-		if (!fields) return;
-		for (const [fieldName, fieldDef] of Object.entries(fields)) {
-			const config = fieldDef?.state?.config;
-			if (config?.type === "blocks" && Array.isArray(config.allowedBlocks)) {
-				for (const blockType of config.allowedBlocks) if (!registeredNames.has(blockType)) console.warn(`[admin] Unknown block type "${blockType}" in allowedBlocks for field "${fieldName}" in ${context}. Registered block types: ${[...registeredNames].join(", ")}`);
-			}
-		}
-	};
-	if (state.collections) for (const [name, collection] of Object.entries(state.collections)) checkFields(collection?.state?.fields, `collection "${name}"`);
-	if (state.globals) for (const [name, global] of Object.entries(state.globals)) checkFields(global?.state?.fields, `global "${name}"`);
-}
-/**
-* Patch CollectionBuilder with admin methods
-*/
-function patchCollectionBuilder() {
-	const proto = CollectionBuilder.prototype;
-	/**
-	* Set admin metadata for the collection.
-	* Defines how the collection appears in the admin sidebar and UI.
-	*
-	* @example
-	* ```ts
-	* .admin(({ c }) => ({
-	*   label: { en: "Posts", sk: "Príspevky" },
-	*   icon: c.icon("ph:article"),
-	*   description: { en: "Blog posts and articles" },
-	* }))
-	* ```
-	*/
-	proto.admin = function(configOrFn) {
-		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(this.state) }) : configOrFn;
-		const newBuilder = new CollectionBuilder({
-			...this.state,
-			admin: config
-		});
-		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
-		return newBuilder;
-	};
-	/**
-	* Configure list view for the collection.
-	* Defines columns, sorting, filtering, and actions for the list page.
-	*
-	* @example
-	* ```ts
-	* .list(({ v, f, a }) => v.table({
-	*   columns: [f.title, f.author, f.status, f.createdAt],
-	*   defaultSort: { field: "createdAt", direction: "desc" },
-	*   searchable: ["title", "content"],
-	*   filterable: ["status", "author"],
-	*   actions: {
-	*     header: { primary: [a.create] },
-	*     row: [a.duplicate, a.delete],
-	*     bulk: [a.delete],
-	*   },
-	* }))
-	* ```
-	*/
-	proto.list = function(configFn) {
-		const fieldNames = Object.keys(this.state.fields || {});
-		const registeredListViews = getRegisteredViewNames(this.state, "list");
-		const config = configFn({
-			v: createViewProxy("list", registeredListViews),
-			f: createFieldProxy(fieldNames),
-			a: createActionProxy()
-		});
-		ensureRegisteredView("list", config.view, registeredListViews);
-		const newBuilder = new CollectionBuilder({
-			...this.state,
-			adminList: config
-		});
-		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
-		return newBuilder;
-	};
-	/**
-	* Configure form view for the collection.
-	* Defines field layout, sections, and tabs for create/edit pages.
-	*
-	* @example
-	* ```ts
-	* .form(({ v, f }) => v.form({
-	*   sections: [
-	*     {
-	*       label: { en: "Basic Info" },
-	*       fields: [f.title, f.slug, f.content],
-	*     },
-	*     {
-	*       label: { en: "Publishing" },
-	*       fields: [f.status, f.publishedAt, f.author],
-	*       collapsible: true,
-	*     },
-	*   ],
-	* }))
-	* ```
-	*/
-	proto.form = function(configFn) {
-		const fieldNames = Object.keys(this.state.fields || {});
-		const registeredEditViews = getRegisteredViewNames(this.state, "edit");
-		const config = configFn({
-			v: createViewProxy("edit", registeredEditViews),
-			f: createFieldProxy(fieldNames)
-		});
-		ensureRegisteredView("edit", config.view, registeredEditViews);
-		const newBuilder = new CollectionBuilder({
-			...this.state,
-			adminForm: config
-		});
-		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
-		return newBuilder;
-	};
-	/**
-	* Configure preview for the collection.
-	* Enables live preview panel in the edit page.
-	*
-	* @example
-	* ```ts
-	* .preview({
-	*   enabled: true,
-	*   url: ({ record, locale }) => `/preview/posts/${record.slug}?locale=${locale}`,
-	*   position: "right",
-	*   defaultWidth: 50,
-	* })
-	* ```
-	*/
-	proto.preview = function(config) {
-		const newBuilder = new CollectionBuilder({
-			...this.state,
-			adminPreview: config
-		});
-		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
-		return newBuilder;
-	};
-	/**
-	* Configure actions for the collection.
-	* Enables built-in actions (create, delete, etc.) and custom actions with forms.
-	*
-	* Form fields use the same field registry as collections. The field proxy `f`
-	* is resolved at build time when the full field registry is available.
-	*
-	* @example
-	* ```ts
-	* .actions(({ a, c, f }) => ({
-	*   builtin: [a.create(), a.delete(), a.deleteMany(), a.duplicate()],
-	*   custom: [
-	*     a.action({
-	*       id: "publish",
-	*       label: { en: "Publish" },
-	*       icon: c.icon("ph:check-circle"),
-	*       confirmation: {
-	*         title: { en: "Publish this item?" },
-	*         description: { en: "This will make the item visible to the public." },
-	*       },
-	*       handler: async ({ itemId, app, db }) => {
-	*         // publish logic
-	*         return { type: "success", toast: { message: "Published!" } };
-	*       },
-	*     }),
-	*     a.action({
-	*       id: "send-email",
-	*       label: { en: "Send Email" },
-	*       icon: c.icon("ph:envelope"),
-	*       form: {
-	*         title: { en: "Send Email" },
-	*         fields: {
-	*           subject: f.text({ label: { en: "Subject" }, required: true }),
-	*           message: f.textarea({ label: { en: "Message" } }),
-	*         },
-	*       },
-	*       handler: async ({ data }) => {
-	*         // send email logic - data.subject, data.message are typed
-	*         return { type: "success", toast: { message: "Email sent!" } };
-	*       },
-	*     }),
-	*     a.bulkAction({
-	*       id: "bulk-publish",
-	*       label: { en: "Publish Selected" },
-	*       handler: async ({ itemIds }) => {
-	*         // bulk publish logic
-	*         return { type: "success", toast: { message: `${itemIds?.length} items published!` } };
-	*       },
-	*     }),
-	*   ],
-	* }))
-	* ```
-	*/
-	proto.actions = function(configFn) {
-		const builderFields = this.state["~questpieApp"]?.state?.fields;
-		const fieldRegistry = {};
-		if (builderFields && Object.keys(builderFields).length > 0) for (const [name, fieldDef] of Object.entries(builderFields)) fieldRegistry[name] = (config$1) => createFieldDefinition(fieldDef, config$1);
-		const config = configFn(createActionsConfigContext(this.state, fieldRegistry));
-		const newBuilder = new CollectionBuilder({
-			...this.state,
-			adminActions: config
-		});
-		if (this._indexesFn) newBuilder._indexesFn = this._indexesFn;
-		return newBuilder;
-	};
-	/**
-	* Patch .merge() to propagate admin extension properties.
-	*
-	* The core .merge() only merges hardcoded collection properties (fields,
-	* indexes, hooks, access, etc.). Admin extensions (admin, adminList,
-	* adminForm, adminPreview, adminActions) would be lost without this patch.
-	*/
-	const originalMerge = proto.merge;
-	proto.merge = function(other) {
-		const result = originalMerge.call(this, other);
-		for (const key of [
-			"admin",
-			"adminList",
-			"adminForm",
-			"adminPreview",
-			"adminActions"
-		]) {
-			const thisVal = this.state[key];
-			const otherVal = other.state[key];
-			if (otherVal !== void 0) result.state[key] = otherVal;
-			else if (thisVal !== void 0) result.state[key] = thisVal;
-		}
-		return result;
-	};
-}
-/**
-* Patch GlobalBuilder with admin methods
-*/
-function patchGlobalBuilder() {
-	const proto = GlobalBuilder.prototype;
-	/**
-	* Set admin metadata for the global.
-	* Defines how the global appears in the admin sidebar and UI.
-	*
-	* @example
-	* ```ts
-	* .admin(({ c }) => ({
-	*   label: { en: "Site Settings", sk: "Nastavenia stránky" },
-	*   icon: c.icon("ph:gear"),
-	* }))
-	* ```
-	*/
-	proto.admin = function(configOrFn) {
-		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(this.state) }) : configOrFn;
-		return new GlobalBuilder({
-			...this.state,
-			admin: config
-		});
-	};
-	/**
-	* Configure form view for the global.
-	* Defines field layout, sections, and tabs for the settings page.
-	*
-	* @example
-	* ```ts
-	* .form(({ v, f }) => v.form({
-	*   tabs: [
-	*     {
-	*       label: { en: "General" },
-	*       icon: c.icon("ph:gear"),
-	*       sections: [
-	*         { fields: [f.siteName, f.siteDescription, f.logo] },
-	*       ],
-	*     },
-	*     {
-	*       label: { en: "Social Media" },
-	*       icon: c.icon("ph:share-network"),
-	*       sections: [
-	*         { fields: [f.socialLinks] },
-	*       ],
-	*     },
-	*   ],
-	* }))
-	* ```
-	*/
-	proto.form = function(configFn) {
-		const fieldNames = Object.keys(this.state.fields || {});
-		const registeredEditViews = getRegisteredViewNames(this.state, "edit");
-		const config = configFn({
-			v: createViewProxy("edit", registeredEditViews),
-			f: createFieldProxy(fieldNames)
-		});
-		ensureRegisteredView("edit", config.view, registeredEditViews);
-		return new GlobalBuilder({
-			...this.state,
-			adminForm: config
-		});
-	};
-}
-/**
-* Apply all admin patches to builder prototypes.
-* This function is idempotent - calling it multiple times has no effect.
-*
-* Called automatically when adminModule is used via .use()
-*/
-function applyAdminPatches() {
-	if (patchesApplied) return;
-	patchQuestpieBuilder();
-	patchCollectionBuilder();
-	patchGlobalBuilder();
-	patchesApplied = true;
-}
-/**
-* Check if admin patches have been applied.
-* Useful for debugging and testing.
-*/
-function arePatchesApplied() {
-	return patchesApplied;
-}
-applyAdminPatches();
-
-//#endregion
-export { applyAdminPatches, arePatchesApplied, createActionProxy, createComponentProxy, createFieldProxy, createViewProxy };
-//# sourceMappingURL=patch.mjs.map