rimecms 0.28.10 → 0.30.0

package/dist/core/fields/builders/select-builder.d.ts

@@ -1,9 +1,11 @@
+import type { DataType } from './form-field-builder.js';
 import { FormFieldBuilder } from './form-field-builder.js';
-import type { DefaultValueFn, FormField, Option } from '../../../fields/types.js';
+import type { DefaultValueFn, FieldValidationFunc, FormField, Option } from '../../../fields/types.js';
 type FieldWithOptions = FormField & {
     options: Option[];
     defaultValue?: (string | DefaultValueFn<string>) | (string[] | DefaultValueFn<string[]>);
     many?: boolean;
+    validate?: FieldValidationFunc<FieldWithOptions>;
 };
 declare class PickFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends FormFieldBuilder<T> {
     constructor(name: string, type: string);
@@ -17,6 +19,7 @@ declare class PickFieldBuilder<T extends FieldWithOptions = FieldWithOptions> ex
 }
 export declare class PickOneFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends PickFieldBuilder<T> {
     defaultValue(value: string | DefaultValueFn<string>): this;
+    get dataType(): DataType;
 }
 export declare class PickManyFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends PickFieldBuilder<T> {
     defaultValue(value: string[] | DefaultValueFn<string[]>): this;

package/dist/core/fields/builders/select-builder.js

@@ -61,6 +61,9 @@ export class PickOneFieldBuilder extends PickFieldBuilder {
         this.field.defaultValue = value;
         return this;
     }
+    get dataType() {
+        return 'text';
+    }
 }
 export class PickManyFieldBuilder extends PickFieldBuilder {
     defaultValue(value) {

package/dist/core/fields/util.d.ts

@@ -1,6 +1,7 @@
 import type { Field, FormField, SeparatorField } from '../../fields/types.js';
 import type { Dic } from '../../util/types.js';
-import type { FieldBuilder } from './builders';
+import type { FormFieldBuilder } from './builders/form-field-builder.js';
+import type { FieldBuilder } from './builders/index.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
  * Presentative fields are used for UI organization and don't store data.
@@ -10,24 +11,15 @@ export declare const isPresentative: (field: Field) => field is SeparatorField;
  * Checks if a field is a form field (has a name property).
  * Form fields are fields that can store data in documents.
  */
-export declare const isFormField: (field: Field) => field is FormField;
+export declare const isFormField: <T extends Field>(field: FieldBuilder<T>) => field is FormFieldBuilder<T & FormField>;
 /**
  * Checks if a form field is not hidden.
  */
-export declare const isNotHidden: (field: FormField) => boolean;
+export declare const isNotHidden: <T extends FormField>(field: FormFieldBuilder<T>) => boolean;
 /**
  * Checks if a field has live updates enabled.
  */
 export declare const isLiveField: (field: Field) => boolean | undefined;
-/**
- * Flattens a nested field structure into an array of form fields.
- * Handles special field types like tabs, tree, and blocks.
- *
- * @example
- * // Flattens a tabs field into its constituent form fields
- * const fields = [tabsField].reduce(toFormFields, []);
- */
-export declare function toFormFields(prev: any[], curr: any): any;
 /**
  * Creates an object with empty values based on field configurations.
  * Uses defaultValue if specified, otherwise undefined.
@@ -43,7 +35,7 @@ export declare function toFormFields(prev: any[], curr: any): any;
  *   ]}
  * ]);
  */
-export declare const emptyValuesFromFieldConfig: <T extends FormField>(arr: T[]) => Dic;
+export declare const emptyValuesFromFieldConfig: <T extends FormFieldBuilder>(arr: T[]) => Dic;
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -59,13 +51,13 @@ export declare function pathToRegex(path: string): RegExp;
  * Retrieves a field configuration by its dot-notation path
  * @example
  * // Get the title field in the attributes group
- * const titleField = getFieldConfigByPath('attributes.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.title', collection.fields);
  *
  * // Get the title field in a specific block
- * const titleField = getFieldConfigByPath('attributes.layout.2:blockType.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.layout.2:blockType.title', collection.fields);
  *
  */
-export declare const getFieldConfigByPath: (path: string, fields: Field[]) => FormField | undefined;
+export declare const getFieldAtPath: (path: string, fields: FieldBuilder[]) => FormFieldBuilder<FormField> | undefined;
 /**
  * Traverses a FieldBuilder[] tree and returns the subset of builders to pass to
  * RenderFields, along with the path prefix those builders should be rendered at.
@@ -74,7 +66,7 @@ export declare const getFieldConfigByPath: (path: string, fields: Field[]) => Fo
  * Blocks are treated as endpoints — the blocks builder itself is returned
  * regardless of any index:blockType suffix in the path.
  */
-export declare function getFieldBuildersAtPath(fieldPath: string, builders: FieldBuilder[], parentPath?: string): {
+export declare function getFieldListAtPath(fieldPath: string, fields: FieldBuilder[], parentPath?: string): {
     fields: FieldBuilder[];
     path: string;
 };

package/dist/core/fields/util.js

@@ -1,7 +1,7 @@
-import { BlocksBuilder, isBlocksFieldRaw } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder, isGroupFieldRaw } from '../../fields/group/index.js';
-import { isTabsFieldRaw, TabsBuilder } from '../../fields/tabs/index.js';
-import { isTreeFieldRaw, TreeBuilder } from '../../fields/tree/index.js';
+import { BlocksBuilder } from '../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { TabsBuilder } from '../../fields/tabs/index.js';
+import { TreeBuilder } from '../../fields/tree/index.js';
 import { normalizeFieldPath } from '../../util/doc.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
@@ -12,48 +12,15 @@ export const isPresentative = (field) => ['separator'].includes(field.type);
  * Checks if a field is a form field (has a name property).
  * Form fields are fields that can store data in documents.
  */
-export const isFormField = (field) => 'name' in field;
+export const isFormField = (field) => field.name !== '';
 /**
  * Checks if a form field is not hidden.
  */
-export const isNotHidden = (field) => !field.hidden;
+export const isNotHidden = (field) => !field.get.hidden;
 /**
  * Checks if a field has live updates enabled.
  */
 export const isLiveField = (field) => field.live;
-/**
- * Flattens a nested field structure into an array of form fields.
- * Handles special field types like tabs, tree, and blocks.
- *
- * @example
- * // Flattens a tabs field into its constituent form fields
- * const fields = [tabsField].reduce(toFormFields, []);
- */
-export function toFormFields(prev, curr) {
-    if (curr.type === 'tabs') {
-        return curr.tabs.reduce(toFormFields, prev);
-    }
-    else if (curr.type === 'tree') {
-        curr = {
-            ...curr,
-            fields: curr.fields.reduce(toFormFields, [])
-        };
-    }
-    else if (curr.type === 'blocks') {
-        curr = {
-            ...curr,
-            blocks: curr.blocks.map((b) => ({
-                ...b,
-                fields: b.fields.reduce(toFormFields, [])
-            }))
-        };
-    }
-    else if ('fields' in curr) {
-        return curr.fields.reduce(toFormFields, prev);
-    }
-    prev.push(curr);
-    return prev;
-}
 /**
  * Creates an object with empty values based on field configurations.
  * Uses defaultValue if specified, otherwise undefined.
@@ -73,24 +40,23 @@ export const emptyValuesFromFieldConfig = (arr) => {
     return Object.fromEntries(arr.map((config) => {
         let emptyValue;
         // Handle group fields - create nested object structure
-        if (isGroupFieldRaw(config)) {
-            emptyValue = emptyValuesFromFieldConfig(config.fields.filter(isFormField));
+        if (config instanceof GroupFieldBuilder) {
+            emptyValue = emptyValuesFromFieldConfig(config.get.fields.filter(isFormField));
         }
         // Handle tabs fields - create nested object structure for each tab
-        else if (isTabsFieldRaw(config)) {
+        else if (config instanceof TabsBuilder) {
             const tabsValue = {};
-            const tabs = config.tabs;
+            const tabs = config.get.tabs;
             for (const tab of tabs) {
                 if ('fields' in tab) {
-                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.fields.filter(isFormField));
+                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.get.fields.filter(isFormField));
                 }
             }
             emptyValue = tabsValue;
         }
         // Handle default values
-        else if ('defaultValue' in config) {
-            emptyValue =
-                typeof config.defaultValue === 'function' ? config.defaultValue() : config.defaultValue;
+        else {
+            emptyValue = config.run.defaultValue();
         }
         return [config.name, emptyValue];
     }));
@@ -118,13 +84,13 @@ export function pathToRegex(path) {
  * Retrieves a field configuration by its dot-notation path
  * @example
  * // Get the title field in the attributes group
- * const titleField = getFieldConfigByPath('attributes.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.title', collection.fields);
  *
  * // Get the title field in a specific block
- * const titleField = getFieldConfigByPath('attributes.layout.2:blockType.title', collection.fields);
+ * const titleField = getFieldAtPath('attributes.layout.2:blockType.title', collection.fields);
  *
  */
-export const getFieldConfigByPath = (path, fields) => {
+export const getFieldAtPath = (path, fields) => {
     const parts = path.split('.');
     const findInFields = (currentFields, remainingParts) => {
         if (remainingParts.length === 0)
@@ -132,10 +98,10 @@ export const getFieldConfigByPath = (path, fields) => {
         const currentPart = remainingParts[0];
         for (const field of currentFields) {
             // Handle tabs
-            if (isTabsFieldRaw(field)) {
-                const tab = field.tabs.find((t) => t.name === currentPart);
+            if (field instanceof TabsBuilder) {
+                const tab = field.get.tabs.find((t) => t.name === currentPart);
                 if (tab) {
-                    return findInFields(tab.fields, remainingParts.slice(1));
+                    return findInFields(tab.get.fields, remainingParts.slice(1));
                 }
                 continue;
             }
@@ -145,22 +111,22 @@ export const getFieldConfigByPath = (path, fields) => {
                     if (remainingParts.length === 1) {
                         return field;
                     }
-                    if (isGroupFieldRaw(field)) {
-                        return findInFields(field.fields, remainingParts.slice(1));
+                    if (field instanceof GroupFieldBuilder) {
+                        return findInFields(field.get.fields, remainingParts.slice(1));
                     }
                     // Handle blocks
-                    if (isBlocksFieldRaw(field) && remainingParts.length > 1) {
+                    if (field instanceof BlocksBuilder && remainingParts.length > 1) {
                         // const blockPartPattern = /:[a-zA-Z0-9]+/
                         const blockType = remainingParts[1].split(':')[1];
                         if (blockType) {
-                            const block = field.blocks.find((b) => b.name === blockType);
+                            const block = field.get.blocks.find((b) => b.name === blockType);
                             if (block) {
-                                return findInFields(block.fields, remainingParts.slice(2));
+                                return findInFields(block.get.fields, remainingParts.slice(2));
                             }
                         }
                     }
-                    if (isTreeFieldRaw(field)) {
-                        return findInFields(field.fields, remainingParts.slice(2));
+                    if (field instanceof TreeBuilder) {
+                        return findInFields(field.get.fields, remainingParts.slice(2));
                     }
                 }
             }
@@ -177,67 +143,67 @@ export const getFieldConfigByPath = (path, fields) => {
  * Blocks are treated as endpoints — the blocks builder itself is returned
  * regardless of any index:blockType suffix in the path.
  */
-export function getFieldBuildersAtPath(fieldPath, builders, parentPath = '') {
+export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
     if (!fieldPath)
-        return { fields: builders, path: parentPath };
+        return { fields, path: parentPath };
     const dotIndex = fieldPath.indexOf('.');
     const head = dotIndex === -1 ? fieldPath : fieldPath.slice(0, dotIndex);
     const tail = dotIndex === -1 ? '' : fieldPath.slice(dotIndex + 1);
     const isEndpoint = fieldPath.split('.').length === 1;
     const nextParentPath = normalizeFieldPath(`${parentPath}${parentPath ? '.' : ''}${head}`);
-    for (const builder of builders) {
+    for (const field of fields) {
         // ── Tabs container: navigate into the matching tab
-        if (builder instanceof TabsBuilder) {
-            const tab = builder.field.tabs.find((t) => t.name === head);
+        if (field instanceof TabsBuilder) {
+            const tab = field.field.tabs.find((t) => t.name === head);
             if (!tab)
                 continue;
             if (isEndpoint) {
                 // Path targets the tab → return all its inner fields
-                return { fields: tab.raw.fields, path: nextParentPath };
+                return { fields: tab.get.fields, path: nextParentPath };
             }
-            return getFieldBuildersAtPath(tail, tab.raw.fields, nextParentPath);
+            return getFieldListAtPath(tail, tab.get.fields, nextParentPath);
         }
-        if (!isFormField(builder.raw))
+        if (!isFormField(field))
             continue;
         // ── Group field: navigate into children
-        if (builder instanceof GroupFieldBuilder && builder.raw.name === head) {
-            const children = builder.field.fields;
+        if (field instanceof GroupFieldBuilder && field.name === head) {
+            const children = field.get.fields;
             if (isEndpoint)
                 return { fields: children, path: nextParentPath };
-            return getFieldBuildersAtPath(tail, children, nextParentPath);
+            return getFieldListAtPath(tail, children, nextParentPath);
         }
         // —— Blocks
-        if (builder instanceof BlocksBuilder && builder.raw.name === head) {
+        if (field instanceof BlocksBuilder && field.name === head) {
             const blockType = tail.split('.')[0]?.split(':')[1];
             const isInnerBlockLookup = tail.split('.').length > 1;
             const nextParentPathWithBlockIndex = `${nextParentPath}.${tail.split('.')[0]}`;
             if (blockType) {
-                const block = builder.raw.blocks.find((b) => b.name === blockType);
-                if (!isInnerBlockLookup && block?.raw.fields) {
+                const block = field.get.blocks.find((b) => b.name === blockType);
+                if (!isInnerBlockLookup && block?.get.fields) {
                     return {
-                        fields: block?.raw.fields,
+                        fields: block.get.fields,
                         path: normalizeFieldPath(nextParentPathWithBlockIndex)
                     };
                 }
                 if (block) {
-                    return getFieldBuildersAtPath(tail.split('.').slice(1).join('.'), block?.raw.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
+                    return getFieldListAtPath(tail.split('.').slice(1).join('.'), block.get.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
                 }
             }
-            return { fields: [builder], path: parentPath };
+            return { fields: [field], path: parentPath };
         }
         // Tree
-        if (builder instanceof TreeBuilder && builder.raw.name === head) {
-            const children = builder.raw.fields;
+        if (field instanceof TreeBuilder && field.name === head) {
+            const children = field.get.fields;
             const nextParentPathWithIndex = `${nextParentPath}.${tail.split('.')[0]}`;
             if (isEndpoint)
                 return { fields: children, path: nextParentPath };
-            return getFieldBuildersAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
+            return getFieldListAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
         }
         // Direct unique field match
-        if (isEndpoint && isFormField(builder.raw) && builder.raw.name === fieldPath) {
-            return { fields: [builder], path: parentPath };
+        if (isEndpoint && isFormField(field) && field.name === fieldPath) {
+            return { fields: [field], path: parentPath };
         }
     }
     console.warn(`[LiveEditPanel] fieldPath "${fieldPath}" not found in config fields`);
-    return { fields: builders, path: parentPath };
+    return { fields, path: parentPath };
 }

package/dist/core/handlers/routes.server.d.ts

@@ -1,2 +1,71 @@
-import { type Handle } from '@sveltejs/kit';
+import { areaLoad } from '../../panel/pages/area/load.server.js';
+import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
+import { collectionLoad } from '../../panel/pages/collection/load.server.js';
+import { liveLoad } from '../../panel/pages/live/load.server.js';
+import { checkLiveRedirect } from '../../panel/util/live.server.js';
+import { type Handle, type RequestEvent, type ServerLoadEvent } from '@sveltejs/kit';
+/**
+ * Backs the fixed set of generated /panel/[slug=collection|area]/... and
+ * /api/[slug=collection|area]/... routes — each of these reads slug/id off
+ * event.params itself (a real dynamic route param), so the generated file
+ * just passes event straight through, no import needed. The param matchers
+ * (src/params/collection.ts, area.ts) already disambiguate collection vs
+ * area at the router level, so rest.collection/rest.area need no runtime
+ * isArea/id branching — each generated route calls the one method that
+ * matches its own folder. Deliberately lives outside rime.server.ts: app
+ * authors never touch this, and importing these panel/api wrappers there
+ * would make RimeContext's inferred type depend on functions that read
+ * event.locals.rime — i.e. on itself.
+ */
+export declare const routeHandlers: {
+    checkLiveRedirect: typeof checkLiveRedirect;
+    panel: {
+        load: {
+            collection: typeof collectionLoad;
+            document: typeof documentLoad;
+            documentVersions: (event: ServerLoadEvent) => Promise<import("../../panel/index.js").CollectionDocData<true>>;
+            area: typeof areaLoad;
+            areaVersions: (event: ServerLoadEvent) => Promise<import("../../panel/index.js").AreaDocData<true>>;
+            dashboard: (event: ServerLoadEvent) => Promise<{
+                entries: import("../../panel/pages/dashboard/types.js").DashboardEntry[];
+                aria: import("../../types.js").Route[];
+            }>;
+            live: typeof liveLoad;
+            signIn: ({ locals }: ServerLoadEvent) => Promise<{
+                forgotPasswordEnabled: boolean;
+                image: string | null;
+                form: {};
+            }>;
+            forgotPassword: ({ locals }: ServerLoadEvent) => Promise<{
+                form: {};
+                image: string | null;
+            }>;
+            resetPassword: ({ locals, url }: ServerLoadEvent) => Promise<{
+                image: string | null;
+                token: string;
+            }>;
+        };
+        actions: {
+            document: import("@sveltejs/kit").Actions;
+            area: import("@sveltejs/kit").Actions;
+            signIn: (event: RequestEvent) => any;
+        };
+    };
+    rest: {
+        collection: {
+            get: typeof import("../collections/rest/get.server.js").restGet;
+            getById: typeof import("../collections/rest/getById.server.js").restGetById;
+            deleteById: typeof import("../collections/rest/deleteById.server.js").restDeleteById;
+            delete: typeof import("../collections/rest/delete.server.js").restDelete;
+            create: typeof import("../collections/rest/create.server.js").restCreate;
+            updateById: typeof import("../collections/rest/updateById.server.js").restUpdateById;
+            duplicate: typeof import("../collections/rest/duplicate.server.js").restDuplicate;
+        };
+        area: {
+            get: typeof import("../areas/rest/get.server.js").restGet;
+            update: typeof import("../areas/rest/update.server.js").restUpdate;
+        };
+    };
+};
 export declare const handleRoutes: Handle;
+export type RouteHandlers = typeof routeHandlers;

package/dist/core/handlers/routes.server.js

@@ -1,13 +1,80 @@
+import { prototypeKebabToSlug } from '../naming.js';
 import buildNavigation from '../../panel/navigation.js';
+import { areaFormActions } from '../../panel/pages/area/actions.server.js';
+import { areaLoad } from '../../panel/pages/area/load.server.js';
+import { forgotPasswordLoad } from '../../panel/pages/auth/forgot-password/load.server.js';
+import { resetPasswordLoad } from '../../panel/pages/auth/reset-password/load.server.js';
+import { signInActions } from '../../panel/pages/auth/sign-in/actions.server.js';
+import { signInLoad } from '../../panel/pages/auth/sign-in/load.server.js';
+import { collectionFormActions } from '../../panel/pages/collection-document/actions.server.js';
+import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
+import { collectionLoad } from '../../panel/pages/collection/load.server.js';
+import { dashboardLoad } from '../../panel/pages/dashboard/load.server.js';
+import { liveLoad } from '../../panel/pages/live/load.server.js';
+import { checkLiveRedirect } from '../../panel/util/live.server.js';
 import {} from '@sveltejs/kit';
+import { rest as areaRest } from '../areas/rest/index.server.js';
+import { rest as collectionRest } from '../collections/rest/index.server.js';
+/**
+ * Backs the fixed set of generated /panel/[slug=collection|area]/... and
+ * /api/[slug=collection|area]/... routes — each of these reads slug/id off
+ * event.params itself (a real dynamic route param), so the generated file
+ * just passes event straight through, no import needed. The param matchers
+ * (src/params/collection.ts, area.ts) already disambiguate collection vs
+ * area at the router level, so rest.collection/rest.area need no runtime
+ * isArea/id branching — each generated route calls the one method that
+ * matches its own folder. Deliberately lives outside rime.server.ts: app
+ * authors never touch this, and importing these panel/api wrappers there
+ * would make RimeContext's inferred type depend on functions that read
+ * event.locals.rime — i.e. on itself.
+ */
+export const routeHandlers = {
+    checkLiveRedirect,
+    panel: {
+        load: {
+            collection: collectionLoad,
+            document: documentLoad,
+            documentVersions: (event) => documentLoad(event, true),
+            area: areaLoad,
+            areaVersions: (event) => areaLoad(event, true),
+            dashboard: dashboardLoad,
+            live: liveLoad,
+            signIn: signInLoad,
+            forgotPassword: forgotPasswordLoad,
+            resetPassword: resetPasswordLoad
+        },
+        actions: {
+            document: collectionFormActions,
+            area: areaFormActions,
+            signIn: signInActions.default
+        }
+    },
+    rest: {
+        collection: collectionRest,
+        area: areaRest
+    }
+};
 export const handleRoutes = async ({ event, resolve }) => {
     const { rime, user } = event.locals;
-    const isSignInRoute = event.url.pathname === '/panel/sign-in';
-    const isPanelRoute = event.url.pathname.startsWith('/panel') && !isSignInRoute;
+    const IS_SIGN_IN_ROUTE = event.url.pathname === '/panel/sign-in';
+    const IS_API_ROUTE = event.url.pathname.startsWith('/api');
+    const IS_PANEL_ROUTE = event.url.pathname.startsWith('/panel') && !IS_SIGN_IN_ROUTE;
+    // event.params.slug comes straight from the URL, always kebab-case (see
+    // src/params/collection.ts, area.ts). Collection/area slugs themselves are
+    // camelCase, so rewrite once here — every downstream handler (panel
+    // load/actions, REST) can then keep comparing event.params.slug directly
+    // against the config's `slug`. Scoped to routes actually matched via our
+    // own [slug=collection]/[slug=area] param matchers (route.id carries the
+    // matcher name) — a consumer's own app route can also use a `slug` param
+    // (e.g. (front)/pages/[slug]) and must be left untouched.
+    if ((IS_API_ROUTE || IS_PANEL_ROUTE) && event.params.slug) {
+        event.params.slug = prototypeKebabToSlug(event.params.slug);
+    }
     // build panel navigation
-    if (isPanelRoute && event.request.method === 'GET') {
-        event.locals.routes = buildNavigation(rime.config.raw, user);
+    if (IS_PANEL_ROUTE && event.request.method === 'GET') {
+        event.locals.navigation = buildNavigation(rime.config.raw, user);
     }
+    event.locals.routes = routeHandlers;
     // Handle custom routes from config and plugins
     const routes = '$routes' in rime.config.raw ? rime.config.raw.$routes : null;
     if (routes && event.url.pathname in routes) {

package/dist/core/naming.d.ts

@@ -10,6 +10,17 @@ import type { CollectionSlug } from '../types.js';
  * withDirectoriesSuffix('pages_versions');
  */
 export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
+/**
+ * Remove a _directories suffix to a given name.
+ * Used for uploads path slug and tables.
+ * Prevent a version table name from being used, force the use of the main one.
+ *
+ * @example
+ * // Returns 'pages'
+ * withoutDirectoriesSuffix('pages_directories');
+ * withoutDirectoriesSuffix('pages_versions_directories');
+ */
+export declare const withoutDirectoriesSuffix: (slug: string) => CollectionSlug;
 /**
  * Add a _versions suffix to a given name.
  * Used for document versioning slug and tables.
@@ -19,6 +30,15 @@ export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
  * withVersionsSuffix('pages');
  */
 export declare const withVersionsSuffix: (name: string) => CollectionSlug;
+/**
+ * Remove a _versions suffix from a given name.
+ * Used for document versioning slug and tables.
+ *
+ * @example
+ * // Returns 'pages'
+ * withoutVersionsSuffix('pages_versions');
+ */
+export declare const withoutVersionsSuffix: (name: string) => CollectionSlug;
 /**
  * Check if a slug is a verioned collection slug
  *  * @example
@@ -46,3 +66,17 @@ export declare const hasDirectoriesSuffix: (slug: string) => boolean;
  * withLocalesSuffix('pages_versions');
  */
 export declare const withLocalesSuffix: (name: string) => string;
+/**
+ * Convert a kebab-case prototype slug.
+ * Basically used to convert param matchers slug into a collection/area slug.
+ * Only a literal trailing `_directories`/`_versions` suffix is preserved as a
+ * suffix — everything else, including a plain `-versions`/`-directories`
+ * word, is camelCased like any other segment.
+ *
+ * @example
+ * prototypeKebabToSlug('my-collection') // returns 'myCollection'
+ * prototypeKebabToSlug('my-collection_directories') // returns 'myCollection_directories'
+ * prototypeKebabToSlug('my-collection_versions') // returns 'myCollection_versions'
+ * prototypeKebabToSlug('my-collection-versions') // returns 'myCollectionVersions'
+ */
+export declare const prototypeKebabToSlug: (kebab: string) => string;

package/dist/core/naming.js

@@ -9,6 +9,17 @@
  * withDirectoriesSuffix('pages_versions');
  */
 export const withDirectoriesSuffix = (slug) => `${slug.replace('_versions', '')}_directories`;
+/**
+ * Remove a _directories suffix to a given name.
+ * Used for uploads path slug and tables.
+ * Prevent a version table name from being used, force the use of the main one.
+ *
+ * @example
+ * // Returns 'pages'
+ * withoutDirectoriesSuffix('pages_directories');
+ * withoutDirectoriesSuffix('pages_versions_directories');
+ */
+export const withoutDirectoriesSuffix = (slug) => slug.replace('_directories', '');
 /**
  * Add a _versions suffix to a given name.
  * Used for document versioning slug and tables.
@@ -18,6 +29,15 @@ export const withDirectoriesSuffix = (slug) => `${slug.replace('_versions', '')}
  * withVersionsSuffix('pages');
  */
 export const withVersionsSuffix = (name) => `${name}_versions`;
+/**
+ * Remove a _versions suffix from a given name.
+ * Used for document versioning slug and tables.
+ *
+ * @example
+ * // Returns 'pages'
+ * withoutVersionsSuffix('pages_versions');
+ */
+export const withoutVersionsSuffix = (name) => name.replace('_versions', '');
 /**
  * Check if a slug is a verioned collection slug
  *  * @example
@@ -45,3 +65,22 @@ export const hasDirectoriesSuffix = (slug) => slug.endsWith('_directories');
  * withLocalesSuffix('pages_versions');
  */
 export const withLocalesSuffix = (name) => `${name}Locales`;
+/**
+ * Convert a kebab-case prototype slug.
+ * Basically used to convert param matchers slug into a collection/area slug.
+ * Only a literal trailing `_directories`/`_versions` suffix is preserved as a
+ * suffix — everything else, including a plain `-versions`/`-directories`
+ * word, is camelCased like any other segment.
+ *
+ * @example
+ * prototypeKebabToSlug('my-collection') // returns 'myCollection'
+ * prototypeKebabToSlug('my-collection_directories') // returns 'myCollection_directories'
+ * prototypeKebabToSlug('my-collection_versions') // returns 'myCollection_versions'
+ * prototypeKebabToSlug('my-collection-versions') // returns 'myCollectionVersions'
+ */
+export const prototypeKebabToSlug = (kebab) => {
+    const suffixMatch = kebab.match(/(_(?:directories|versions))$/);
+    const suffix = suffixMatch ? suffixMatch[1] : '';
+    const base = suffix ? kebab.slice(0, -suffix.length) : kebab;
+    return base.replace(/-([a-z])/g, (_, char) => char.toUpperCase()) + suffix;
+};

package/dist/core/operations/blocks/diff.server.js

@@ -10,7 +10,7 @@ export function defineBlocksDiff({ existingBlocks, incomingBlocks, context }) {
     // - If a block is not localized than it should keep its id so block is updated
     if (context.isFallbackLocale) {
         incomingBlocks = incomingBlocks.map((block) => {
-            const isLocalized = configMap[block.path]?.localized || false;
+            const isLocalized = configMap[block.path]?.get.localized || false;
             if (isLocalized) {
                 delete block.id;
                 block.locale = context.isFallbackLocale;

package/dist/core/operations/blocks/extract.server.js

@@ -5,7 +5,7 @@ export function extractBlocks({ data, configMap }) {
     Object.entries(configMap).forEach(([path, config]) => {
         if (config.type === 'blocks') {
             const value = getValueAtPath(path, data);
-            const isEmptyValue = config.isEmpty(value);
+            const isEmptyValue = config.run.isEmpty(value);
             if (value && !isEmptyValue) {
                 value.forEach((block, index) => {
                     if (block.type) {

package/dist/core/operations/configMap/buildTreeMap.d.ts

@@ -1,3 +1,4 @@
-import type { TreeFieldRaw } from '../../../fields/tree/index.js';
+import type { TreeBlock } from '../../types/doc.js';
+import type { TreeBuilder } from '../../../fields/tree/index.js';
 import type { ConfigMap } from './types.js';
-export declare function buildTreeFieldsMap(treeConfig: TreeFieldRaw, treeItems: any[], basePath: string): ConfigMap;
+export declare function buildTreeFieldsMap(treeConfig: TreeBuilder, treeItems: TreeBlock[], basePath: string): ConfigMap;

package/dist/core/operations/configMap/buildTreeMap.js

@@ -3,7 +3,7 @@ export function buildTreeFieldsMap(treeConfig, treeItems, basePath) {
     const treeMap = {};
     // Helper to add field configs for a specific path
     const addFieldConfigs = (path) => {
-        for (const field of treeConfig.fields) {
+        for (const field of treeConfig.get.fields) {
             if (isFormField(field)) {
                 treeMap[`${path}.${field.name}`] = field;
             }