@questpie/admin 1.1.1 → 3.0.0

package/dist/server/modules/admin/block/introspection.d.mts

@@ -0,0 +1,89 @@
+import { ComponentReference } from "../../../augmentation/common.mjs";
+import { BlockCategoryConfig, FieldLayoutItem } from "../../../augmentation/form-layout.mjs";
+import "../../../augmentation.mjs";
+import { AnyBlockDefinition } from "./block-builder.mjs";
+import { I18nText } from "questpie/shared";
+import { FieldSchema } from "questpie";
+
+//#region src/server/modules/admin/block/introspection.d.ts
+
+/**
+ * Introspected block schema for admin consumption.
+ * All admin metadata comes from the .admin() configuration.
+ */
+interface BlockSchema {
+  /** Block type name */
+  name: string;
+  /** Admin configuration */
+  admin?: {
+    /** Display label */
+    label?: I18nText;
+    /** Description */
+    description?: I18nText;
+    /** Icon reference */
+    icon?: ComponentReference;
+    /** Category for grouping in block picker */
+    category?: BlockCategoryConfig;
+    /** Order within category in block picker */
+    order?: number;
+    /** Hide from block picker */
+    hidden?: boolean;
+  };
+  /** Allow child blocks */
+  allowChildren?: boolean;
+  /** Maximum number of child blocks */
+  maxChildren?: number;
+  /** Has prefetch function */
+  hasPrefetch: boolean;
+  /** Field schemas - unified format using FieldSchema */
+  fields: Record<string, FieldSchema>;
+  /** Form layout for block fields (sections, tabs, grid) */
+  form?: {
+    fields: FieldLayoutItem[];
+  };
+  /** Validation schemas */
+  validation?: {
+    insert?: unknown;
+    update?: unknown;
+  };
+}
+/**
+ * Category info extracted from blocks for UI rendering.
+ */
+interface CategoryInfo {
+  /** Category key (derived from label or auto-generated) */
+  key: string;
+  /** Category configuration */
+  config: BlockCategoryConfig;
+  /** Blocks in this category */
+  blocks: BlockSchema[];
+}
+/**
+ * Introspect a single block definition.
+ * Handles both server BlockBuilder definitions and client BlockDefinition objects
+ * that were converted via the `.blocks()` patch.
+ */
+declare function introspectBlock(blockDef: AnyBlockDefinition): BlockSchema;
+/**
+ * Introspect all registered blocks.
+ *
+ * @param blocks - Record of registered block definitions
+ * @returns Record of block schemas
+ *
+ * @example
+ * ```ts
+ * import { introspectBlocks } from "@questpie/admin/server";
+ *
+ * // In an API route
+ * const blocks = introspectBlocks(app.state.blocks);
+ * return Response.json({ blocks });
+ * ```
+ */
+declare function introspectBlocks(blocks: Record<string, AnyBlockDefinition> | undefined): Record<string, BlockSchema>;
+/**
+ * Get blocks grouped by category with full category info.
+ * Useful for block picker UI.
+ */
+declare function getBlocksByCategory(blocks: Record<string, BlockSchema>): CategoryInfo[];
+//#endregion
+export { BlockSchema, getBlocksByCategory, introspectBlock, introspectBlocks };

package/dist/server/modules/admin/block/introspection.mjs

@@ -0,0 +1,100 @@
+import { isI18nLocaleMap } from "questpie/shared";
+
+//#region src/server/modules/admin/block/introspection.ts
+/**
+* Normalize a block entry to a BlockDefinition.
+* App state may contain either built BlockDefinition objects (with getFieldMetadata)
+* or raw BlockBuilder instances (with a .build() method). This normalizes both
+* to a BlockDefinition by calling .build() on builders.
+*/
+function normalizeBlockDef(blockDef) {
+	if (typeof blockDef?.build === "function" && !blockDef.getFieldMetadata) return blockDef.build();
+	return blockDef;
+}
+/**
+* Introspect a single block definition.
+* Handles both server BlockBuilder definitions and client BlockDefinition objects
+* that were converted via the `.blocks()` patch.
+*/
+function introspectBlock(blockDef) {
+	const resolved = normalizeBlockDef(blockDef);
+	const state = resolved.state;
+	return {
+		name: state.name ?? resolved.name,
+		admin: state.admin,
+		allowChildren: state.allowChildren,
+		maxChildren: state.maxChildren,
+		hasPrefetch: typeof state.prefetch === "function",
+		fields: resolved.getFieldMetadata(),
+		form: state.form
+	};
+}
+/**
+* Introspect all registered blocks.
+*
+* @param blocks - Record of registered block definitions
+* @returns Record of block schemas
+*
+* @example
+* ```ts
+* import { introspectBlocks } from "@questpie/admin/server";
+*
+* // In an API route
+* const blocks = introspectBlocks(app.state.blocks);
+* return Response.json({ blocks });
+* ```
+*/
+function introspectBlocks(blocks) {
+	if (!blocks) return {};
+	const schemas = {};
+	for (const [name, blockDef] of Object.entries(blocks)) schemas[name] = introspectBlock(blockDef);
+	return schemas;
+}
+/**
+* Generate a category key from category config.
+* Uses English label as key, falling back to first available label.
+*/
+function getCategoryKey(category) {
+	const { label } = category;
+	if (typeof label === "string") return label.toLowerCase().replace(/\s+/g, "-");
+	if (isI18nLocaleMap(label)) return (label.en ?? Object.values(label)[0] ?? "").toLowerCase().replace(/\s+/g, "-");
+	return label.key.toLowerCase().replace(/[.:]/g, "-");
+}
+/**
+* Get blocks grouped by category with full category info.
+* Useful for block picker UI.
+*/
+function getBlocksByCategory(blocks) {
+	const categoryMap = /* @__PURE__ */ new Map();
+	const uncategorizedKey = "uncategorized";
+	const uncategorizedConfig = {
+		label: { en: "Uncategorized" },
+		order: 999
+	};
+	for (const block of Object.values(blocks)) {
+		if (block.admin?.hidden) continue;
+		const categoryConfig = block.admin?.category;
+		let key;
+		let config;
+		if (categoryConfig) {
+			key = getCategoryKey(categoryConfig);
+			config = categoryConfig;
+		} else {
+			key = uncategorizedKey;
+			config = uncategorizedConfig;
+		}
+		if (!categoryMap.has(key)) categoryMap.set(key, {
+			key,
+			config,
+			blocks: []
+		});
+		categoryMap.get(key).blocks.push(block);
+	}
+	const categories = Array.from(categoryMap.values());
+	categories.sort((a, b) => (a.config.order ?? 999) - (b.config.order ?? 999));
+	for (const category of categories) category.blocks.sort((a, b) => (a.admin?.order ?? 999) - (b.admin?.order ?? 999));
+	return categories;
+}
+
+//#endregion
+export { getBlocksByCategory, introspectBlock, introspectBlocks };

package/dist/server/modules/admin/block/prefetch.d.mts

@@ -0,0 +1,78 @@
+import { BlocksDocument } from "../../../fields/blocks.mjs";
+import { AnyBlockDefinition } from "./block-builder.mjs";
+
+//#region src/server/modules/admin/block/prefetch.d.ts
+
+/**
+ * Context for blocks prefetch processing.
+ * Use `typedApp<App>(ctx.app)` for typed access.
+ */
+interface BlocksPrefetchContext {
+  /** app instance — use `typedApp<App>(ctx.app)` for typed access */
+  app: any;
+  /** Database client */
+  db: unknown;
+  /** Current locale */
+  locale?: string;
+}
+/**
+ * Process blocks data for a single blocks document.
+ *
+ * This function does two things:
+ * 1. **Expands declared fields** from `.prefetch({ with: [...] })` (batch-fetched)
+ * 2. **Executes prefetch functions/loaders** for blocks that have them
+ *
+ * The results are merged into `_data[blockId]`. Prefetch function / loader data
+ * takes precedence over expanded data on key conflicts.
+ *
+ * @param blocks - The blocks document to process
+ * @param blockDefinitions - Registered block definitions
+ * @param ctx - Prefetch context
+ * @returns The blocks document with `_data` populated
+ */
+declare function processBlocksDocument(blocks: BlocksDocument | null | undefined, blockDefinitions: Record<string, AnyBlockDefinition>, ctx: BlocksPrefetchContext): Promise<BlocksDocument | null | undefined>;
+/**
+ * Process blocks prefetch for a document.
+ * Finds all blocks fields in the document and processes them.
+ *
+ * @param doc - The document containing blocks fields
+ * @param fieldDefinitions - Field definitions to identify blocks fields
+ * @param blockDefinitions - Registered block definitions
+ * @param ctx - Prefetch context
+ * @returns The document with blocks prefetch data attached
+ */
+declare function processDocumentBlocksPrefetch<T extends Record<string, unknown>>(doc: T, fieldDefinitions: Record<string, {
+  _state: {
+    customType?: string;
+    type: string;
+  };
+}>, blockDefinitions: Record<string, AnyBlockDefinition>, ctx: BlocksPrefetchContext): Promise<T>;
+/**
+ * Create an afterRead hook for processing blocks prefetch.
+ * This hook can be added to collections that have blocks fields.
+ *
+ * @example
+ * ```ts
+ * // collections/pages/index.ts
+ * import { collection } from "questpie";
+ * import { createBlocksPrefetchHook } from "@questpie/admin/server";
+ *
+ * export default collection("pages", {
+ *   fields: ({ f }) => ({
+ *     title: f.text({ required: true }),
+ *     content: f.blocks({ allowedBlocks: ["hero", "text"] }),
+ *   }),
+ *   hooks: {
+ *     afterRead: createBlocksPrefetchHook(),
+ *   },
+ * });
+ * ```
+ */
+declare function createBlocksPrefetchHook(): (ctx: {
+  data: Record<string, unknown>;
+  app: any;
+  db: unknown;
+  locale?: string;
+}) => Promise<void>;
+//#endregion
+export { BlocksPrefetchContext, createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };

package/dist/server/modules/admin/block/prefetch.mjs

@@ -0,0 +1,241 @@
+//#region src/server/modules/admin/block/prefetch.ts
+/**
+* Expand relation/upload fields declared in `prefetchWith`.
+*
+* Uses the same object syntax as `with` in find operations:
+* ```ts
+* { backgroundImage: true, author: { with: { avatar: true } } }
+* ```
+*
+* Nested `with` is passed through to the collection's `find` call,
+* reusing the existing relation resolution machinery.
+*
+* @internal
+*/
+async function expandDeclaredFields(allNodes, values, blockDefinitions, ctx) {
+	const expansionsByCollection = /* @__PURE__ */ new Map();
+	for (const node of allNodes) {
+		const blockDef = blockDefinitions[node.type];
+		const prefetchWith = blockDef?.state.prefetchWith;
+		if (!prefetchWith || typeof prefetchWith !== "object") continue;
+		if (!blockDef?.state.fields) continue;
+		const blockValues = values[node.id] || {};
+		for (const [fieldName, fieldConfig] of Object.entries(prefetchWith)) {
+			if (!fieldConfig) continue;
+			const fieldDef = blockDef.state.fields[fieldName];
+			if (!fieldDef || typeof fieldDef !== "object") continue;
+			const metadata = "getMetadata" in fieldDef && typeof fieldDef.getMetadata === "function" ? fieldDef.getMetadata() : void 0;
+			if (!metadata) continue;
+			if (metadata.type !== "relation") continue;
+			const targetCollection = metadata.targetCollection;
+			if (!targetCollection || typeof targetCollection !== "string") continue;
+			const value = blockValues[fieldName];
+			if (!value) continue;
+			const stringIds = (Array.isArray(value) ? value : [value]).filter((id) => typeof id === "string" && id.length > 0);
+			if (stringIds.length === 0) continue;
+			const nestedWith = typeof fieldConfig === "object" && fieldConfig.with ? fieldConfig.with : void 0;
+			const groupKey = nestedWith ? `${targetCollection}:${JSON.stringify(nestedWith)}` : targetCollection;
+			if (!expansionsByCollection.has(groupKey)) expansionsByCollection.set(groupKey, {
+				ids: /* @__PURE__ */ new Set(),
+				targets: [],
+				nestedWith
+			});
+			const entry = expansionsByCollection.get(groupKey);
+			for (const id of stringIds) entry.ids.add(id);
+			entry.targets.push({
+				blockId: node.id,
+				fieldName,
+				isSingle: !Array.isArray(value),
+				nestedWith
+			});
+		}
+	}
+	if (expansionsByCollection.size === 0) return {};
+	const fetchedByGroup = /* @__PURE__ */ new Map();
+	const fetchPromises = [...expansionsByCollection.entries()].map(async ([groupKey, { ids, nestedWith }]) => {
+		const collection = groupKey.includes(":") ? groupKey.slice(0, groupKey.indexOf(":")) : groupKey;
+		try {
+			const collectionApi = ctx.app?.collections?.[collection];
+			if (!collectionApi?.find) {
+				console.warn(`[prefetch] Collection "${collection}" not found on app.collections, skipping`);
+				return;
+			}
+			const result = await collectionApi.find({
+				where: { id: { in: [...ids] } },
+				limit: ids.size,
+				...nestedWith ? { with: nestedWith } : {}
+			});
+			const recordMap = /* @__PURE__ */ new Map();
+			for (const doc of result?.docs || []) if (doc && typeof doc === "object" && "id" in doc) recordMap.set(doc.id, doc);
+			fetchedByGroup.set(groupKey, recordMap);
+		} catch (error) {
+			console.error(`[prefetch] Failed to fetch from "${collection}":`, error);
+		}
+	});
+	await Promise.all(fetchPromises);
+	const expandedData = {};
+	for (const [groupKey, { targets }] of expansionsByCollection) {
+		const recordMap = fetchedByGroup.get(groupKey);
+		if (!recordMap) continue;
+		for (const { blockId, fieldName, isSingle } of targets) {
+			if (!expandedData[blockId]) expandedData[blockId] = {};
+			const blockVal = values[blockId]?.[fieldName];
+			if (isSingle) expandedData[blockId][fieldName] = recordMap.get(blockVal) ?? null;
+			else {
+				const ids = blockVal;
+				expandedData[blockId][fieldName] = ids.map((id) => recordMap.get(id)).filter(Boolean);
+			}
+		}
+	}
+	return expandedData;
+}
+/**
+* Process blocks data for a single blocks document.
+*
+* This function does two things:
+* 1. **Expands declared fields** from `.prefetch({ with: [...] })` (batch-fetched)
+* 2. **Executes prefetch functions/loaders** for blocks that have them
+*
+* The results are merged into `_data[blockId]`. Prefetch function / loader data
+* takes precedence over expanded data on key conflicts.
+*
+* @param blocks - The blocks document to process
+* @param blockDefinitions - Registered block definitions
+* @param ctx - Prefetch context
+* @returns The blocks document with `_data` populated
+*/
+async function processBlocksDocument(blocks, blockDefinitions, ctx) {
+	if (!blocks || !blocks._tree || !blocks._values) return blocks;
+	const allNodes = [];
+	const collectNodes = (nodes) => {
+		for (const node of nodes) {
+			allNodes.push(node);
+			if (node.children.length > 0) collectNodes(node.children);
+		}
+	};
+	collectNodes(blocks._tree);
+	const expandedData = await expandDeclaredFields(allNodes, blocks._values, blockDefinitions, ctx);
+	const prefetchedData = await executePrefetchFunctions(allNodes, blocks._values, blockDefinitions, ctx, expandedData);
+	const mergedData = {};
+	const allBlockIds = new Set([...Object.keys(expandedData), ...Object.keys(prefetchedData)]);
+	for (const blockId of allBlockIds) mergedData[blockId] = {
+		...expandedData[blockId] || {},
+		...prefetchedData[blockId] || {}
+	};
+	return {
+		...blocks,
+		_data: mergedData
+	};
+}
+/**
+* Execute prefetch functions and loaders for blocks.
+*
+* Handles two shapes:
+* - Shape 1: `state.prefetch` — call with `{ values, ctx }`
+* - Shape 3: `state._prefetchLoader` — call with `{ values, expanded, ctx }`
+*
+* Shape 2 (with-only) has no function to call — expansion is handled separately.
+*
+* @internal
+*/
+async function executePrefetchFunctions(allNodes, values, blockDefinitions, ctx, expandedData) {
+	const prefetchedData = {};
+	const prefetchPromises = [];
+	for (const node of allNodes) {
+		const blockDef = blockDefinitions[node.type];
+		if (!blockDef) continue;
+		const blockValues = values[node.id] || {};
+		const prefetchCtx = {
+			blockId: node.id,
+			blockType: node.type,
+			...ctx,
+			locale: ctx.locale
+		};
+		const loader = blockDef.state._prefetchLoader;
+		if (typeof loader === "function") {
+			const expanded = expandedData[node.id] || {};
+			prefetchPromises.push((async () => {
+				try {
+					const data = await loader({
+						values: blockValues,
+						expanded,
+						ctx: prefetchCtx
+					});
+					if (data && typeof data === "object") prefetchedData[node.id] = data;
+				} catch (error) {
+					console.error(`Block prefetch loader failed for ${node.type}:${node.id}:`, error);
+					prefetchedData[node.id] = { _error: "Prefetch failed" };
+				}
+			})());
+		} else if (blockDef.state.prefetch) prefetchPromises.push((async () => {
+			try {
+				const data = await blockDef.executePrefetch(blockValues, prefetchCtx);
+				prefetchedData[node.id] = data;
+			} catch (error) {
+				console.error(`Block prefetch failed for ${node.type}:${node.id}:`, error);
+				prefetchedData[node.id] = { _error: "Prefetch failed" };
+			}
+		})());
+	}
+	await Promise.all(prefetchPromises);
+	return prefetchedData;
+}
+/**
+* Process blocks prefetch for a document.
+* Finds all blocks fields in the document and processes them.
+*
+* @param doc - The document containing blocks fields
+* @param fieldDefinitions - Field definitions to identify blocks fields
+* @param blockDefinitions - Registered block definitions
+* @param ctx - Prefetch context
+* @returns The document with blocks prefetch data attached
+*/
+async function processDocumentBlocksPrefetch(doc, fieldDefinitions, blockDefinitions, ctx) {
+	if (!doc || !blockDefinitions || Object.keys(blockDefinitions).length === 0) return doc;
+	const result = { ...doc };
+	for (const [fieldName, fieldDef] of Object.entries(fieldDefinitions)) if ((fieldDef?._state?.customType ?? fieldDef?._state?.type) === "blocks" && result[fieldName]) result[fieldName] = await processBlocksDocument(result[fieldName], blockDefinitions, ctx);
+	return result;
+}
+/**
+* Create an afterRead hook for processing blocks prefetch.
+* This hook can be added to collections that have blocks fields.
+*
+* @example
+* ```ts
+* // collections/pages/index.ts
+* import { collection } from "questpie";
+* import { createBlocksPrefetchHook } from "@questpie/admin/server";
+*
+* export default collection("pages", {
+*   fields: ({ f }) => ({
+*     title: f.text({ required: true }),
+*     content: f.blocks({ allowedBlocks: ["hero", "text"] }),
+*   }),
+*   hooks: {
+*     afterRead: createBlocksPrefetchHook(),
+*   },
+* });
+* ```
+*/
+function createBlocksPrefetchHook() {
+	return async (ctx) => {
+		const blocks = ctx.app?.state?.blocks;
+		if (!blocks || Object.keys(blocks).length === 0) return;
+		for (const [key, value] of Object.entries(ctx.data)) if (isBlocksDocument(value)) ctx.data[key] = await processBlocksDocument(value, blocks, {
+			app: ctx.app,
+			db: ctx.db,
+			locale: ctx.locale
+		});
+	};
+}
+/**
+* Check if a value is a blocks document.
+*/
+function isBlocksDocument(value) {
+	if (!value || typeof value !== "object") return false;
+	const doc = value;
+	return Array.isArray(doc._tree) && typeof doc._values === "object" && doc._values !== null;
+}
+
+//#endregion
+export { createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch };

package/dist/server/modules/admin/client/.generated/module.d.mts

@@ -0,0 +1,94 @@
+import { ViewDefinition } from "../../../../../client/builder/view/view.mjs";
+import { Badge, IconifyIcon } from "../../../../../client/components/component-renderer.mjs";
+import "../../../../../index.mjs";
+import "../components/badge.mjs";
+import "../components/icon.mjs";
+import { _default } from "../fields/array.mjs";
+import { _default as _default$1 } from "../fields/assetPreview.mjs";
+import { _default as _default$2 } from "../fields/blocks.mjs";
+import { _default as _default$3 } from "../fields/boolean.mjs";
+import { _default as _default$4 } from "../fields/date.mjs";
+import { _default as _default$5 } from "../fields/datetime.mjs";
+import { _default as _default$6 } from "../fields/email.mjs";
+import { _default as _default$7 } from "../fields/json.mjs";
+import { _default as _default$8 } from "../fields/number.mjs";
+import { _default as _default$9 } from "../fields/object.mjs";
+import { _default as _default$10 } from "../fields/relation.mjs";
+import { _default as _default$11 } from "../fields/richText.mjs";
+import { _default as _default$12 } from "../fields/select.mjs";
+import { _default as _default$13 } from "../fields/text.mjs";
+import { _default as _default$14 } from "../fields/textarea.mjs";
+import { _default as _default$15 } from "../fields/time.mjs";
+import { _default as _default$16 } from "../fields/upload.mjs";
+import { _default as _default$17 } from "../fields/url.mjs";
+import { _default as _default$18 } from "../pages/dashboard.mjs";
+import { _default as _default$19 } from "../pages/forgotPassword.mjs";
+import { _default as _default$20 } from "../pages/login.mjs";
+import { _default as _default$21 } from "../pages/resetPassword.mjs";
+import { _default as _default$22 } from "../pages/setup.mjs";
+import { _default as _default$23 } from "../widgets/chart.mjs";
+import { _default as _default$24 } from "../widgets/progress.mjs";
+import { _default as _default$25 } from "../widgets/quickActions.mjs";
+import { _default as _default$26 } from "../widgets/recentItems.mjs";
+import { _default as _default$27 } from "../widgets/stats.mjs";
+import { _default as _default$28 } from "../widgets/table.mjs";
+import { _default as _default$29 } from "../widgets/timeline.mjs";
+import { _default as _default$30 } from "../widgets/value.mjs";
+
+//#region src/server/modules/admin/client/.generated/module.d.ts
+interface AdminComponents {
+  badge: typeof Badge;
+  icon: typeof IconifyIcon;
+}
+interface AdminFields {
+  array: typeof _default;
+  assetPreview: typeof _default$1;
+  blocks: typeof _default$2;
+  boolean: typeof _default$3;
+  date: typeof _default$4;
+  datetime: typeof _default$5;
+  email: typeof _default$6;
+  json: typeof _default$7;
+  number: typeof _default$8;
+  object: typeof _default$9;
+  relation: typeof _default$10;
+  richText: typeof _default$11;
+  select: typeof _default$12;
+  text: typeof _default$13;
+  textarea: typeof _default$14;
+  time: typeof _default$15;
+  upload: typeof _default$16;
+  url: typeof _default$17;
+}
+interface AdminPages {
+  dashboard: typeof _default$18;
+  forgotPassword: typeof _default$19;
+  login: typeof _default$20;
+  resetPassword: typeof _default$21;
+  setup: typeof _default$22;
+}
+interface AdminWidgets {
+  chart: typeof _default$23;
+  progress: typeof _default$24;
+  quickActions: typeof _default$25;
+  recentItems: typeof _default$26;
+  stats: typeof _default$27;
+  table: typeof _default$28;
+  timeline: typeof _default$29;
+  value: typeof _default$30;
+}
+declare const _module: {
+  name: "questpie-admin";
+  views: {
+    "collection-form": ViewDefinition<"collection-form", "form">;
+    "collection-table": ViewDefinition<"collection-table", "list">;
+    "global-form": ViewDefinition<"global-form", "form">;
+  };
+  components: AdminComponents;
+  fields: AdminFields;
+  pages: AdminPages;
+  widgets: AdminWidgets;
+  blocks: {};
+};
+//#endregion
+export { _module };

package/dist/server/modules/admin/client/.generated/module.mjs

@@ -0,0 +1,91 @@
+import collection_form_default from "../views/collection-form.mjs";
+import collection_table_default from "../views/collection-table.mjs";
+import global_form_default from "../views/global-form.mjs";
+import { Badge, IconifyIcon } from "../../../../../client/components/component-renderer.mjs";
+import array_default from "../fields/array.mjs";
+import assetPreview_default from "../fields/assetPreview.mjs";
+import blocks_default from "../fields/blocks.mjs";
+import boolean_default from "../fields/boolean.mjs";
+import date_default from "../fields/date.mjs";
+import datetime_default from "../fields/datetime.mjs";
+import email_default from "../fields/email.mjs";
+import json_default from "../fields/json.mjs";
+import number_default from "../fields/number.mjs";
+import object_default from "../fields/object.mjs";
+import relation_default from "../fields/relation.mjs";
+import richText_default from "../fields/richText.mjs";
+import select_default from "../fields/select.mjs";
+import text_default from "../fields/text.mjs";
+import textarea_default from "../fields/textarea.mjs";
+import time_default from "../fields/time.mjs";
+import upload_default from "../fields/upload.mjs";
+import url_default from "../fields/url.mjs";
+import dashboard_default from "../pages/dashboard.mjs";
+import forgotPassword_default from "../pages/forgotPassword.mjs";
+import login_default from "../pages/login.mjs";
+import resetPassword_default from "../pages/resetPassword.mjs";
+import setup_default from "../pages/setup.mjs";
+import chart_default from "../widgets/chart.mjs";
+import progress_default from "../widgets/progress.mjs";
+import quickActions_default from "../widgets/quickActions.mjs";
+import recentItems_default from "../widgets/recentItems.mjs";
+import stats_default from "../widgets/stats.mjs";
+import table_default from "../widgets/table.mjs";
+import timeline_default from "../widgets/timeline.mjs";
+import value_default from "../widgets/value.mjs";
+
+//#region src/server/modules/admin/client/.generated/module.ts
+const _module = {
+	name: "questpie-admin",
+	views: {
+		[collection_form_default.name]: collection_form_default,
+		[collection_table_default.name]: collection_table_default,
+		[global_form_default.name]: global_form_default
+	},
+	components: {
+		badge: Badge,
+		icon: IconifyIcon
+	},
+	fields: {
+		array: array_default,
+		assetPreview: assetPreview_default,
+		blocks: blocks_default,
+		boolean: boolean_default,
+		date: date_default,
+		datetime: datetime_default,
+		email: email_default,
+		json: json_default,
+		number: number_default,
+		object: object_default,
+		relation: relation_default,
+		richText: richText_default,
+		select: select_default,
+		text: text_default,
+		textarea: textarea_default,
+		time: time_default,
+		upload: upload_default,
+		url: url_default
+	},
+	pages: {
+		dashboard: dashboard_default,
+		forgotPassword: forgotPassword_default,
+		login: login_default,
+		resetPassword: resetPassword_default,
+		setup: setup_default
+	},
+	widgets: {
+		chart: chart_default,
+		progress: progress_default,
+		quickActions: quickActions_default,
+		recentItems: recentItems_default,
+		stats: stats_default,
+		table: table_default,
+		timeline: timeline_default,
+		value: value_default
+	},
+	blocks: {}
+};
+var module_default = _module;
+
+//#endregion
+export { module_default as default };