includio-cms 0.1.3 → 0.5.0

package/dist/paraglide/server.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * This middleware performs several key functions:
+ *
+ * 1. Determines the locale for the incoming request using configured strategies
+ * 2. Handles URL localization and redirects (only for document requests)
+ * 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+ *
+ * When URL strategy is used:
+ *
+ * - The locale is extracted from the URL for all request types
+ * - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+ * - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+ *
+ * @template T - The return type of the resolve function
+ *
+ * @param {Request} request - The incoming request object
+ * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
+ * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @returns {Promise<Response>}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+ * export const handle = async ({ event, resolve }) => {
+ *   return serverMiddleware(event.request, ({ request, locale }) => {
+ *     // let the framework further resolve the request
+ *     return resolve(request);
+ *   });
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in a framework like Express JS or Hono
+ * app.use(async (req, res, next) => {
+ *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in serverless environments like Cloudflare Workers
+ * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
+ * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
+ * // one request could leak into another concurrent request.
+ * export default {
+ *   fetch: async (request) => {
+ *     return serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export function paraglideMiddleware<T>(request: Request, resolve: (args: {
+    request: Request;
+    locale: import("./runtime.js").Locale;
+}) => T | Promise<T>, callbacks?: {
+    onRedirect: (response: Response) => void;
+}): Promise<Response>;

package/dist/paraglide/server.js

@@ -0,0 +1,175 @@
+/* eslint-disable */
+
+import * as runtime from "./runtime.js";
+
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * This middleware performs several key functions:
+ *
+ * 1. Determines the locale for the incoming request using configured strategies
+ * 2. Handles URL localization and redirects (only for document requests)
+ * 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+ *
+ * When URL strategy is used:
+ *
+ * - The locale is extracted from the URL for all request types
+ * - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+ * - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+ *
+ * @template T - The return type of the resolve function
+ *
+ * @param {Request} request - The incoming request object
+ * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
+ * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @returns {Promise<Response>}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+ * export const handle = async ({ event, resolve }) => {
+ *   return serverMiddleware(event.request, ({ request, locale }) => {
+ *     // let the framework further resolve the request
+ *     return resolve(request);
+ *   });
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in a framework like Express JS or Hono
+ * app.use(async (req, res, next) => {
+ *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in serverless environments like Cloudflare Workers
+ * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
+ * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
+ * // one request could leak into another concurrent request.
+ * export default {
+ *   fetch: async (request) => {
+ *     return serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export async function paraglideMiddleware(request, resolve, callbacks) {
+    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
+        const { AsyncLocalStorage } = await import("async_hooks");
+        runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+    }
+    else if (!runtime.serverAsyncLocalStorage) {
+        runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    }
+    const decision = await runtime.shouldRedirect({ request });
+    const locale = decision.locale;
+    const origin = new URL(request.url).origin;
+    // if the client makes a request to a URL that doesn't match
+    // the localizedUrl, redirect the client to the localized URL
+    if (request.headers.get("Sec-Fetch-Dest") === "document" &&
+        decision.shouldRedirect &&
+        decision.redirectUrl) {
+        // Create headers object with Vary header if preferredLanguage strategy is used
+        /** @type {Record<string, string>} */
+        const headers = {};
+        if (runtime.strategy.includes("preferredLanguage")) {
+            headers["Vary"] = "Accept-Language";
+        }
+        const response = new Response(null, {
+            status: 307,
+            headers: {
+                Location: decision.redirectUrl.href,
+                ...headers,
+            },
+        });
+        callbacks?.onRedirect(response);
+        return response;
+    }
+    // If the strategy includes "url", we need to de-localize the URL
+    // before passing it to the server middleware.
+    //
+    // The middleware is responsible for mapping a localized URL to the
+    // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
+    // the server can't render the correct page.
+    const newRequest = runtime.strategy.includes("url")
+        ? new Request(runtime.deLocalizeUrl(request.url), request)
+        : // need to create a new request object because some metaframeworks (nextjs!) throw otherwise
+            // https://github.com/opral/inlang-paraglide-js/issues/411
+            new Request(request);
+    // the message functions that have been called in this request
+    /** @type {Set<string>} */
+    const messageCalls = new Set();
+    const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
+    // Only modify HTML responses
+    if (runtime.experimentalMiddlewareLocaleSplitting &&
+        response.headers.get("Content-Type")?.includes("html")) {
+        const body = await response.text();
+        const messages = [];
+        // using .values() to avoid polyfilling in older projects. else the following error is thrown
+        // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
+        for (const messageCall of Array.from(messageCalls)) {
+            const [id, locale] = 
+            /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
+            messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
+        }
+        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Insert the script before the closing head tag
+        const newBody = body.replace("</head>", `${script}</head>`);
+        // Create a new response with the modified body
+        // Clone all headers except Content-Length which will be set automatically
+        const newHeaders = new Headers(response.headers);
+        newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    return response;
+}
+/**
+ * Creates a mock AsyncLocalStorage implementation for environments where
+ * native AsyncLocalStorage is not available or disabled.
+ *
+ * This mock implementation mimics the behavior of the native AsyncLocalStorage
+ * but doesn't require the async_hooks module. It's designed to be used in
+ * environments like Cloudflare Workers where AsyncLocalStorage is not available.
+ *
+ * @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+ */
+function createMockAsyncLocalStorage() {
+    /** @type {any} */
+    let currentStore = undefined;
+    return {
+        getStore() {
+            return currentStore;
+        },
+        async run(store, callback) {
+            currentStore = store;
+            try {
+                return await callback();
+            }
+            finally {
+                currentStore = undefined;
+            }
+        },
+    };
+}
+/**
+ * The compiled messages for the server middleware.
+ *
+ * Only populated if `enableMiddlewareOptimizations` is set to `true`.
+ *
+ * @type {Record<string, Record<import("./runtime.js").Locale, string>>}
+ */
+const compiledBundles = {};

package/dist/server/auth.d.ts

@@ -2,6 +2,11 @@ export declare const auth: import("better-auth", { with: { "resolution-mode": "r
     database: (options: import("better-auth", { with: { "resolution-mode": "require" } }).BetterAuthOptions) => import("better-auth/adapters/drizzle", { with: { "resolution-mode": "require" } }).DBAdapter<import("better-auth", { with: { "resolution-mode": "require" } }).BetterAuthOptions>;
     emailAndPassword: {
         enabled: true;
+        sendResetPassword({ user, url }: {
+            user: import("better-auth", { with: { "resolution-mode": "require" } }).User;
+            url: string;
+            token: string;
+        }, request: Request | undefined): Promise<void>;
     };
     plugins: [{
         id: "admin";

package/dist/server/auth.js

@@ -2,12 +2,23 @@ import { betterAuth } from 'better-auth';
 import { drizzleAdapter } from 'better-auth/adapters/drizzle';
 import { db } from './db/index.js';
 import { admin } from 'better-auth/plugins';
+import { getCMS } from '../core/cms.js';
+import { resetPasswordEmailTemplate } from '../admin/email/reset-password-template.js';
 export const auth = betterAuth({
     database: drizzleAdapter(db, {
         provider: 'pg'
     }),
     emailAndPassword: {
-        enabled: true
+        enabled: true,
+        async sendResetPassword({ user, url }, request) {
+            const emailAdapter = getCMS().emailAdapter;
+            if (!emailAdapter) {
+                throw new Error('Email adapter not configured');
+            }
+            const lang = request?.headers.get('Accept-Language')?.startsWith('pl') ? 'pl' : 'en';
+            const { subject, html } = resetPasswordEmailTemplate({ resetUrl: url, lang });
+            await emailAdapter.sendMail({ to: [user.email], subject, html });
+        }
     },
     plugins: [admin()]
 });

package/dist/sveltekit/components/structured-content.svelte

@@ -0,0 +1,204 @@
+<script lang="ts" module>
+	import type { SCNode, SCMark, StructuredContentDoc, SCInlineBlockAttrs } from '../../types/structured-content.js';
+	import type { Snippet } from 'svelte';
+
+	export interface StructuredContentProps {
+		doc: StructuredContentDoc;
+		class?: string;
+		/** Override rendering for inline blocks. Receives blockType, blockData, blockId. */
+		inlineBlock?: Snippet<[string, Record<string, unknown>, string]>;
+		/** Override rendering for figure nodes. Receives node attrs. */
+		figure?: Snippet<[Record<string, unknown>]>;
+		/** Override rendering for video nodes. Receives node attrs. */
+		video?: Snippet<[Record<string, unknown>]>;
+		/** Override rendering for heading nodes. Receives level and children snippet. */
+		heading?: Snippet<[number, Snippet]>;
+		/** Override rendering for paragraph nodes. Receives children snippet. */
+		paragraph?: Snippet<[Snippet]>;
+		/** Override rendering for code block nodes. Receives language and text content. */
+		codeBlock?: Snippet<[string | undefined, string]>;
+	}
+</script>
+
+<script lang="ts">
+	import Image from './image.svelte';
+
+	let {
+		doc,
+		class: className,
+		inlineBlock: inlineBlockSnippet,
+		figure: figureSnippet,
+		video: videoSnippet,
+		heading: headingSnippet,
+		paragraph: paragraphSnippet,
+		codeBlock: codeBlockSnippet
+	}: StructuredContentProps = $props();
+
+	function getTextContent(node: SCNode): string {
+		if (node.type === 'text') return node.text ?? '';
+		return node.content?.map(getTextContent).join('') ?? '';
+	}
+</script>
+
+{#snippet renderMark(text: string, marks: SCMark[], index: number)}
+	{#if index >= marks.length}
+		{text}
+	{:else}
+		{@const mark = marks[index]}
+		{#if mark.type === 'bold'}
+			<strong>{@render renderMark(text, marks, index + 1)}</strong>
+		{:else if mark.type === 'italic'}
+			<em>{@render renderMark(text, marks, index + 1)}</em>
+		{:else if mark.type === 'underline'}
+			<u>{@render renderMark(text, marks, index + 1)}</u>
+		{:else if mark.type === 'strike'}
+			<s>{@render renderMark(text, marks, index + 1)}</s>
+		{:else if mark.type === 'code'}
+			<code>{@render renderMark(text, marks, index + 1)}</code>
+		{:else if mark.type === 'highlight'}
+			<mark>{@render renderMark(text, marks, index + 1)}</mark>
+		{:else if mark.type === 'link'}
+			{@const href = (mark.attrs?.href as string) ?? ''}
+			{@const target = mark.attrs?.target as string | undefined}
+			{@const title = mark.attrs?.title as string | undefined}
+			{@const ariaLabel = mark.attrs?.['aria-label'] as string | undefined}
+			<a
+				{href}
+				target={target ?? undefined}
+				rel={target === '_blank' ? 'noopener noreferrer' : undefined}
+				{title}
+				aria-label={ariaLabel ?? undefined}
+			>{@render renderMark(text, marks, index + 1)}</a>
+		{:else}
+			{@render renderMark(text, marks, index + 1)}
+		{/if}
+	{/if}
+{/snippet}
+
+{#snippet renderNode(node: SCNode)}
+	{#if node.type === 'text'}
+		{#if node.marks?.length}
+			{@render renderMark(node.text ?? '', node.marks, 0)}
+		{:else}
+			{node.text}
+		{/if}
+	{:else if node.type === 'paragraph'}
+		{#if paragraphSnippet}
+			{@render paragraphSnippet(renderChildren)}
+		{:else}
+			<p>{@render renderChildren()}</p>
+		{/if}
+	{:else if node.type === 'heading'}
+		{@const level = (node.attrs?.level as number) ?? 2}
+		{#if headingSnippet}
+			{@render headingSnippet(level, renderChildren)}
+		{:else if level === 2}
+			<h2>{@render renderChildren()}</h2>
+		{:else if level === 3}
+			<h3>{@render renderChildren()}</h3>
+		{/if}
+	{:else if node.type === 'blockquote'}
+		<blockquote>{@render renderChildren()}</blockquote>
+	{:else if node.type === 'bulletList'}
+		<ul>{@render renderChildren()}</ul>
+	{:else if node.type === 'orderedList'}
+		<ol>{@render renderChildren()}</ol>
+	{:else if node.type === 'listItem'}
+		<li>{@render renderChildren()}</li>
+	{:else if node.type === 'codeBlock'}
+		{#if codeBlockSnippet}
+			{@render codeBlockSnippet(node.attrs?.language as string | undefined, getTextContent(node))}
+		{:else}
+			{@const lang = node.attrs?.language as string | undefined}
+			<pre><code class={lang ? `language-${lang}` : undefined}>{@render renderChildren()}</code></pre>
+		{/if}
+	{:else if node.type === 'horizontalRule'}
+		<hr>
+	{:else if node.type === 'hardBreak'}
+		<br>
+	{:else if node.type === 'figure'}
+		{#if figureSnippet}
+			{@render figureSnippet(node.attrs ?? {})}
+		{:else}
+			{@const attrs = node.attrs ?? {}}
+			{@const rawMedia = attrs._media as { data: import('../../types/media.js').MediaFile; styles?: Record<string, import('../../types/media.js').ImageStyle>; blurDataUrl?: string | null } | undefined}
+			{@const figMedia = rawMedia?.data ? { data: rawMedia.data, styles: rawMedia.styles ?? {}, blurDataUrl: rawMedia.blurDataUrl } : undefined}
+			<figure>
+				{#if figMedia}
+					<Image data={figMedia} alt={attrs.alt as string ?? figMedia.data.alt ?? ''} />
+				{:else}
+					<img
+						src={attrs.src as string}
+						alt={(attrs.alt as string) ?? ''}
+						width={attrs.width as number ?? undefined}
+						height={attrs.height as number ?? undefined}
+						loading="lazy"
+					>
+				{/if}
+				{#if attrs.caption}
+					<figcaption>{attrs.caption}</figcaption>
+				{/if}
+			</figure>
+		{/if}
+	{:else if node.type === 'image'}
+		{@const attrs = node.attrs ?? {}}
+		{@const rawImgMedia = attrs._media as { data: import('../../types/media.js').MediaFile; styles?: Record<string, import('../../types/media.js').ImageStyle>; blurDataUrl?: string | null } | undefined}
+		{@const imgMedia = rawImgMedia?.data ? { data: rawImgMedia.data, styles: rawImgMedia.styles ?? {}, blurDataUrl: rawImgMedia.blurDataUrl } : undefined}
+		{#if imgMedia}
+			<Image data={imgMedia} alt={attrs.alt as string ?? imgMedia.data.alt ?? ''} />
+		{:else}
+			<img
+				src={attrs.src as string}
+				alt={(attrs.alt as string) ?? ''}
+				width={attrs.width as number ?? undefined}
+				height={attrs.height as number ?? undefined}
+				loading="lazy"
+			>
+		{/if}
+	{:else if node.type === 'video'}
+		{#if videoSnippet}
+			{@render videoSnippet(node.attrs ?? {})}
+		{:else}
+			{@const attrs = node.attrs ?? {}}
+			<video
+				controls
+				poster={attrs.poster as string ?? undefined}
+				width={attrs.width as number ?? undefined}
+				height={attrs.height as number ?? undefined}
+			>
+				<source src={attrs.src as string}>
+			</video>
+		{/if}
+	{:else if node.type === 'table'}
+		<table>{@render renderChildren()}</table>
+	{:else if node.type === 'tableRow'}
+		<tr>{@render renderChildren()}</tr>
+	{:else if node.type === 'tableCell'}
+		<td>{@render renderChildren()}</td>
+	{:else if node.type === 'tableHeader'}
+		<th>{@render renderChildren()}</th>
+	{:else if node.type === 'inlineBlock'}
+		{#if inlineBlockSnippet}
+			{@const attrs = node.attrs as unknown as SCInlineBlockAttrs}
+			{@render inlineBlockSnippet(attrs.blockType, attrs.blockData, attrs.blockId)}
+		{/if}
+	{:else}
+		{@render renderChildren()}
+	{/if}
+
+	{#snippet renderChildren()}
+		{#if node.content}
+			{#each node.content as child}
+				{@render renderNode(child)}
+			{/each}
+		{/if}
+	{/snippet}
+{/snippet}
+
+{#if doc?.content}
+	<div class={className}>
+		{#each doc.content as node}
+			{@render renderNode(node)}
+		{/each}
+	</div>
+{/if}

package/dist/sveltekit/components/structured-content.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { StructuredContentDoc } from '../../types/structured-content.js';
+import type { Snippet } from 'svelte';
+export interface StructuredContentProps {
+    doc: StructuredContentDoc;
+    class?: string;
+    /** Override rendering for inline blocks. Receives blockType, blockData, blockId. */
+    inlineBlock?: Snippet<[string, Record<string, unknown>, string]>;
+    /** Override rendering for figure nodes. Receives node attrs. */
+    figure?: Snippet<[Record<string, unknown>]>;
+    /** Override rendering for video nodes. Receives node attrs. */
+    video?: Snippet<[Record<string, unknown>]>;
+    /** Override rendering for heading nodes. Receives level and children snippet. */
+    heading?: Snippet<[number, Snippet]>;
+    /** Override rendering for paragraph nodes. Receives children snippet. */
+    paragraph?: Snippet<[Snippet]>;
+    /** Override rendering for code block nodes. Receives language and text content. */
+    codeBlock?: Snippet<[string | undefined, string]>;
+}
+declare const StructuredContent: import("svelte").Component<StructuredContentProps, {}, "">;
+type StructuredContent = ReturnType<typeof StructuredContent>;
+export default StructuredContent;

package/dist/sveltekit/config.d.ts

@@ -1,10 +1,20 @@
 import type { CMSConfig } from '../types/cms.js';
 import type { CollectionConfig } from '../types/collections.js';
 import type { SingleConfig } from '../types/singles.js';
-import type { ObjectField } from '../types/fields.js';
+import type { Field, ObjectField } from '../types/fields.js';
 import type { FormConfig } from '../types/forms.js';
+import type { Layout } from '../types/layout.js';
+type CollectionInput = Omit<CollectionConfig, 'fields'> & {
+    fields: Field[];
+    layout?: Layout;
+};
+type SingleInput = Omit<SingleConfig, 'fields'> & {
+    fields: Field[];
+    layout?: Layout;
+};
 export declare function defineConfig(config: CMSConfig): CMSConfig;
-export declare function defineCollection(config: CollectionConfig): CollectionConfig;
-export declare function defineSingle(config: SingleConfig): SingleConfig;
+export declare function defineCollection(config: CollectionInput): CollectionConfig;
+export declare function defineSingle(config: SingleInput): SingleConfig;
 export declare function defineForm(config: FormConfig): FormConfig;
 export declare function defineObject(config: Omit<ObjectField, 'type'>): ObjectField;
+export {};

package/dist/sveltekit/index.d.ts

@@ -5,5 +5,8 @@ export { default as HybridTarget } from './components/hybrid-target.svelte';
 export { default as Image } from './components/image.svelte';
 export { default as Video } from './components/video.svelte';
 export { default as Media } from './components/media.svelte';
+export { default as StructuredContent } from './components/structured-content.svelte';
 export { enableHybridEditing } from './components/hybrid-context.js';
 export { getLink, isImageFieldData, isVideoFieldData } from './utils/index.js';
+export { structuredToHtml } from '../core/fields/structuredToHtml.js';
+export { extractBlocks, extractInlineBlocks, extractText, extractMediaRefs } from '../core/server/fields/queryStructuredContent.js';

package/dist/sveltekit/index.js

@@ -5,5 +5,8 @@ export { default as HybridTarget } from './components/hybrid-target.svelte';
 export { default as Image } from './components/image.svelte';
 export { default as Video } from './components/video.svelte';
 export { default as Media } from './components/media.svelte';
+export { default as StructuredContent } from './components/structured-content.svelte';
 export { enableHybridEditing } from './components/hybrid-context.js';
 export { getLink, isImageFieldData, isVideoFieldData } from './utils/index.js';
+export { structuredToHtml } from '../core/fields/structuredToHtml.js';
+export { extractBlocks, extractInlineBlocks, extractText, extractMediaRefs } from '../core/server/fields/queryStructuredContent.js';

package/dist/sveltekit/server/handle.js

@@ -10,6 +10,7 @@ const adminGuard = async ({ event, resolve }) => {
             !event.url.pathname.startsWith('/api/admin/login') &&
             !event.url.pathname.startsWith('/admin/accept-invite') &&
             !event.url.pathname.startsWith('/admin/api/accept-invite') &&
+            !event.url.pathname.startsWith('/admin/reset-password') &&
             (!user || !session)) {
             setFlash({
                 message: 'You must be logged in to access the admin panel.',

package/dist/types/config.d.ts

@@ -1,8 +1,11 @@
 import type { Field } from './fields.js';
 import type { Icon } from '@tabler/icons-svelte';
+import type { Layout } from './layout.js';
 export interface ConfigBase {
     sidebarIcon?: Icon;
     slug: string;
     previewUrl?: string;
     fields: Field[];
+    layout?: Layout;
+    slugField?: string;
 }

package/dist/types/fields.d.ts

@@ -1,7 +1,8 @@
 import type { FormatEnum } from 'sharp';
 import type { ImageStyle, MediaFile } from './media.js';
 import type { Localized } from './languages.js';
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'file' | 'image' | 'media' | 'select' | 'radio' | 'checkboxes' | 'relation' | 'object' | 'array' | 'slug' | 'seo' | 'url';
+import type { StructuredContentDoc } from './structured-content.js';
+export type FieldType = 'text' | 'richtext' | 'content' | 'number' | 'boolean' | 'date' | 'datetime' | 'file' | 'image' | 'media' | 'select' | 'radio' | 'checkboxes' | 'relation' | 'object' | 'array' | 'blocks' | 'slug' | 'seo' | 'url';
 export interface BaseField {
     slug: string;
     label?: Localized;
@@ -25,6 +26,11 @@ export interface RichtextField extends BaseField {
     allowedFormats?: string[];
     defaultValue?: string;
 }
+export interface ContentField extends BaseField {
+    type: 'content';
+    inlineBlocks?: ObjectField[];
+    defaultValue?: StructuredContentDoc;
+}
 export interface NumberField extends BaseField {
     type: 'number';
     min?: number;
@@ -141,8 +147,16 @@ export interface ObjectFieldData {
     slug?: string;
     data: Record<string, unknown>;
 }
+export type SimpleArrayItemType = 'text' | 'number' | 'url';
 export interface ArrayField extends BaseField {
     type: 'array';
+    of: SimpleArrayItemType;
+    minItems?: number;
+    maxItems?: number;
+    defaultValue?: (string | number | UrlFieldData)[];
+}
+export interface BlocksField extends BaseField {
+    type: 'blocks';
     of: ObjectField[];
     minItems?: number;
     maxItems?: number;
@@ -152,10 +166,13 @@ export interface ArrayField extends BaseField {
 export interface SlugField extends BaseField {
     type: 'slug';
     pattern?: string;
+    sourceField?: string;
     defaultValue?: string;
 }
 export interface SeoField extends BaseField {
     type: 'seo';
+    slugSource?: string;
+    titleSource?: string;
 }
 export interface SeoFieldData {
     slug: string;
@@ -178,4 +195,4 @@ export type UrlFieldData = {
     text?: Record<string, string>;
     newTab?: boolean;
 };
-export type Field = TextField | RichtextField | NumberField | BooleanField | DateField | DateTimeField | FileField | ImageField | MediaField | SelectField | RadioField | CheckboxesField | RelationField | ObjectField | ArrayField | SlugField | SeoField | UrlField;
+export type Field = TextField | RichtextField | ContentField | NumberField | BooleanField | DateField | DateTimeField | FileField | ImageField | MediaField | SelectField | RadioField | CheckboxesField | RelationField | ObjectField | ArrayField | BlocksField | SlugField | SeoField | UrlField;

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from './fields.js';
+export { type StructuredContentDoc, type SCNode, type SCMark, type SCInlineBlockAttrs, type SCFigureAttrs, type SCVideoAttrs } from './structured-content.js';
 export { type MediaFile, type MediaFileType, type ImageStyle, type MediaTag } from './media.js';
 export { type ConsentLogData } from './consent.js';
 export { type Entry, type EntryType, type EntryStatus, type EntryVersionStatus } from './entries.js';
@@ -8,3 +9,4 @@ export { type SingleConfig } from './singles.js';
 export { type FormConfig, type FormSubmission } from './forms.js';
 export { type CMSConfig } from './cms.js';
 export { type Language, type Localized } from './languages.js';
+export { type Layout, type LayoutNode, type LayoutPreset, type LayoutNodeType, type ColumnRatio, type SectionNode, type ColumnsNode, type CardNode, type AccordionNode, type StackNode } from './layout.js';

package/dist/types/index.js

@@ -1,4 +1,5 @@
 export * from './fields.js';
+export {} from './structured-content.js';
 export {} from './media.js';
 export {} from './consent.js';
 export {} from './entries.js';
@@ -8,3 +9,4 @@ export {} from './singles.js';
 export {} from './forms.js';
 export {} from './cms.js';
 export {} from './languages.js';
+export {} from './layout.js';