rimecms 0.31.5 → 0.32.1

package/dist/core/config/server/build-config.server.d.ts

@@ -1,123 +0,0 @@
-import type { SMTPConfig } from '../../plugins/mailer/module.server.js';
-import { type Rime } from '../../rime.server.js';
-import type { Config } from '../types.js';
-export declare const buildConfig: <const C extends Config>(config: C) => Promise<Rime<C>>;
-declare function augmentConfig<T extends Config>(config: T): T & {
-    readonly collections: readonly [...import("../types.js").BuiltCollection[], import("../types.js").BuiltCollection];
-} & {
-    readonly collections: import("../types.js").BuiltCollection[];
-    readonly areas: import("../types.js").BuiltArea[];
-} & {
-    readonly icons: import("../../../util/types.js").Dic<import("svelte").Component<import("@lucide/svelte").LucideProps, {}, string>>;
-} & {
-    readonly panel: {
-        readonly routes: Record<string, import("../types.js").CustomPanelRoute>;
-        readonly language: "fr" | "en";
-        readonly navigation: {
-            readonly groups: readonly [...{
-                label: string;
-                icon: import("svelte").Component<import("@lucide/svelte").IconProps>;
-            }[], {
-                readonly label: "content";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
-            }, {
-                readonly label: "system";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
-            }, {
-                readonly label: "collections";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
-            }, {
-                readonly label: "areas";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
-            }];
-        };
-        readonly components: {
-            readonly dashboard?: import("svelte").Component<{
-                entries: import("../../../panel/pages/dashboard/types.js").DashboardEntry[];
-                user?: import("../../../types.js").User;
-            }, {}, string> | undefined;
-            readonly header: import("svelte").Component<{}, {}, string>[];
-        };
-        readonly css?: string;
-    };
-} & {
-    readonly panel: {
-        $access: (user?: import("../../../types.js").User) => boolean;
-        routes?: Record<string, import("../types.js").CustomPanelRoute>;
-        language?: import("../../..").PanelLanguage;
-        navigation?: {
-            groups: Array<{
-                label: string;
-                icon: import("svelte").Component<import("@lucide/svelte").IconProps>;
-            }>;
-        };
-        components?: {
-            header?: import("svelte").Component[];
-            collectionHeader?: import("svelte").Component<{
-                config: import("../types.js").BuiltCollectionClient;
-            }>[];
-            dashboard?: import("svelte").Component<{
-                entries: import("../../../panel/pages/dashboard/types.js").DashboardEntry[];
-                user?: import("../../../types.js").User;
-            }>;
-        };
-        css?: string;
-    };
-} & {
-    readonly $trustedOrigins: string[];
-} & {
-    readonly $plugins: import("../../plugins/index.js").Plugin[];
-} & {
-    readonly collections: readonly import("../types.js").BuiltCollection[];
-} & {
-    readonly plugins: any[];
-};
-type InferCollections<C> = C extends {
-    collections?: readonly any[];
-} ? {
-    [K in NonNullable<C['collections']>[number] as K extends {
-        slug: infer N;
-    } ? N extends string ? N : never : never]: K;
-} : Record<string, never>;
-type InferAreas<C> = C extends {
-    areas?: readonly any[];
-} ? {
-    [K in NonNullable<C['areas']>[number] as K extends {
-        slug: infer N;
-    } ? N extends string ? N : never : never]: K;
-} : Record<string, never>;
-type InferCollectionsSlug<C> = C extends {
-    collections?: readonly any[];
-} ? NonNullable<C['collections']>[number] extends {
-    slug: infer N;
-} ? N extends string ? N : never : never : Array<never>;
-type InferAreasSlug<C> = C extends {
-    areas?: readonly any[];
-} ? NonNullable<C['areas']>[number] extends {
-    slug: infer N;
-} ? N extends string ? N : never : never : Array<never>;
-type InferCorePlugins<C extends Config> = {
-    cache: import('../../plugins/cache/module.server.js').CacheActions;
-    sse: import('../../plugins/sse/module.server.js').SSEActions;
-} & (C['$smtp'] extends SMTPConfig ? {
-    mailer: import('../../plugins/mailer/module.server.js').MailerActions;
-} : Record<string, never>);
-type ExtractCustomPlugins<C> = C extends {
-    plugins: readonly (infer P)[];
-} ? P extends {
-    name: infer N;
-    actions?: infer A;
-} ? N extends string ? Record<N, NonNullable<A>> : never : never : Record<string, never>;
-type InferPluginsServer<C extends Config> = InferCorePlugins<C> & ExtractCustomPlugins<C>;
-export type BuildConfig<C extends Config = Config> = ReturnType<typeof augmentConfig<C>> & {
-    readonly $InferAuthPlugins: C['$auth'] extends {
-        plugins: any;
-    } ? C['$auth']['plugins'] : [];
-    readonly $InferRoutes: C['$routes'] extends Record<string, any> ? C['$routes'] : unknown;
-    readonly $InferPluginsServer: InferPluginsServer<C>;
-    readonly $InferCollections: InferCollections<C>;
-    readonly $InferAreas: InferAreas<C>;
-    readonly $InferAreasSlug: InferAreasSlug<C>;
-    readonly $InferCollectionsSlug: InferCollectionsSlug<C>;
-};
-export {};

package/dist/core/config/server/build-config.server.js

@@ -1,28 +0,0 @@
-import { createRime } from '../../rime.server.js';
-import { augmentPanel } from '../client/augment-panel.js';
-import { augmentPlugins } from '../client/augment-plugins.js';
-import { augmentIcons } from '../shared/augment-icons.js';
-import { augmentPrototypes } from '../shared/augment-prototypes.js';
-import { makeVersionsCollectionsAliases } from '../shared/versions-alias.server.js';
-import { augmentCORS } from './augment-cors.server.js';
-import { augmentDirectoriesServer } from './augment-directories.server.js';
-import { augmentPanelAccess } from './augment-panel-access.server.js';
-import { augmentPluginsServer } from './augment-plugins.server.js';
-import { augmentStaffServer } from './augment-staff.server.js';
-export const buildConfig = (config) => {
-    const augmented = augmentConfig(config);
-    const output = makeVersionsCollectionsAliases(augmented);
-    return createRime(output);
-};
-function augmentConfig(config) {
-    const withStaff = augmentStaffServer(config);
-    const withPrototype = augmentPrototypes(withStaff);
-    const withIcons = augmentIcons(withPrototype);
-    const withPanel = augmentPanel(withIcons);
-    const withPanelAccess = augmentPanelAccess(withPanel);
-    const withCORS = augmentCORS(withPanelAccess);
-    const withPluginsServer = augmentPluginsServer(withCORS);
-    const withDirectories = augmentDirectoriesServer(withPluginsServer);
-    const output = augmentPlugins(withDirectories);
-    return output;
-}

package/dist/core/config/server/index.server.d.ts

@@ -1,9 +0,0 @@
-import * as Area from '../../areas/config/builder.server.js';
-import * as Collection from '../../collections/config/builder.server.js';
-import { Hooks } from '../../operations/hooks/index.server.js';
-import type { BuiltConfigClient, SanitizedConfigClient } from '../types.js';
-import { buildConfig } from './build-config.server.js';
-export type { BuildConfig } from './build-config.server.js';
-/** placeholder for types */
-declare const rimeClient: (config: SanitizedConfigClient) => BuiltConfigClient;
-export { Area, Collection, Hooks, buildConfig as rime, rimeClient };

package/dist/core/config/server/index.server.js

@@ -1,11 +0,0 @@
-import * as Area from '../../areas/config/builder.server.js';
-import * as Collection from '../../collections/config/builder.server.js';
-import { Hooks } from '../../operations/hooks/index.server.js';
-import { buildConfig } from './build-config.server.js';
-/** placeholder for types */
-const rimeClient = (config) => {
-    throw new Error("Don't use this function, this is a placeholder for types only");
-    // @ts-expect-error this is a placeholder function
-    return config;
-};
-export { Area, Collection, Hooks, buildConfig as rime, rimeClient };

package/dist/core/config/server/validate.server.d.ts

@@ -1,3 +0,0 @@
-import type { Config } from '../types.js';
-declare function validate(config: Config): boolean;
-export default validate;

package/dist/core/config/server/validate.server.js

@@ -1,234 +0,0 @@
-import { isAuthConfig } from '../../collections/auth/util.js';
-import cache from '../../dev/cache/index.server.js';
-import { isFormField } from '../../fields/util.js';
-import { logger } from '../../logger/index.server.js';
-import { withoutDirectoriesSuffix, withoutVersionsSuffix } from '../../naming.js';
-import { BlocksBuilder } from '../../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../../fields/group/index.js';
-import { RelationFieldBuilder } from '../../../fields/relation/index.js';
-import { SelectFieldBuilder } from '../../../fields/select/index.js';
-import { TabsBuilder } from '../../../fields/tabs/index.js';
-import { TreeBuilder } from '../../../fields/tree/index.js';
-import { isCamelCase } from '../../../util/string.js';
-function hasDuplicates(arr) {
-    return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
-}
-/**
- * Check if there are multiple occurences
- * of the same slug inside collections and areas
- */
-function hasDuplicateSlug(config) {
-    const slugs = [];
-    for (const collection of config.collections || []) {
-        slugs.push(collection.slug);
-    }
-    for (const area of config.areas || []) {
-        slugs.push(area.slug);
-    }
-    const duplicates = hasDuplicates(slugs);
-    if (duplicates.length) {
-        return ['Duplicated collection/area slugs :' + duplicates.join(', ')];
-    }
-    return [];
-}
-/**
- * Check that all area/collection slugs are camelCase
- */
-function validateSlugs(config) {
-    const errors = [];
-    const slugs = [
-        ...(config.collections || []).map((c) => c.slug),
-        ...(config.areas || []).map((a) => a.slug)
-    ]
-        .map(withoutVersionsSuffix)
-        .map(withoutDirectoriesSuffix);
-    for (const slug of slugs) {
-        if (!isCamelCase(slug)) {
-            errors.push(`Slug ${slug} is not a valid prototype slug`);
-        }
-    }
-    return errors;
-}
-/**
- * Prevent the panel user collection slug
- * to be used elsewhere
- */
-function hasUsersSlug(config) {
-    const invalid = (config.collections || []).filter((collection) => collection.slug === 'staff').length > 1;
-    if (invalid) {
-        return [`staff is a reserved slug for panel users`];
-    }
-    return [];
-}
-/**
- * Validate documents fields for each collections
- * and areas
- */
-const validateFields = (config) => {
-    let errors = [];
-    for (const collection of config.collections || []) {
-        const collectionErrors = validateDocumentFields(collection, config);
-        errors = [...errors, ...collectionErrors];
-    }
-    for (const area of config.areas || []) {
-        const collectionErrors = validateDocumentFields(area, config);
-        errors = [...errors, ...collectionErrors];
-    }
-    return errors;
-};
-/**
- *
- */
-const validateDocumentFields = (documentConfig, config) => {
-    const errors = [];
-    const isCollection = (documentConfig) => documentConfig.type === 'collection';
-    const isAuth = isCollection(documentConfig) && isAuthConfig(documentConfig);
-    const registeredBlocks = {};
-    // const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
-    if (isAuth) {
-        const rolesField = documentConfig.fields
-            .filter(isFormField)
-            .filter((f) => f.name === 'roles')
-            .filter((f) => f instanceof SelectFieldBuilder)[0];
-        const nameField = documentConfig.fields.filter(isFormField).filter((f) => f.name === 'name')[0];
-        const emailField = documentConfig.fields
-            .filter(isFormField)
-            .find((f) => f.name === 'email' && f.type === 'email');
-        if (!rolesField)
-            errors.push(`Field roles is missing in collection ${documentConfig.slug}`);
-        if (!emailField && documentConfig.auth.type !== 'apiKey')
-            errors.push(`Field email is missing in collection ${documentConfig.slug}`);
-        if (!nameField)
-            errors.push(`Field name is missing in collection ${documentConfig.slug}`);
-        if (!rolesField.get.many)
-            errors.push(`Field roles must have "many" enabled : select('roles').options(...).many(), even with a single option`);
-    }
-    const validateBlockField = (fields, blockType) => {
-        const reserved = ['path', 'type', 'ownerId', 'position', 'locale'];
-        for (const key of reserved) {
-            if (fields
-                .filter(isFormField)
-                .map((f) => f.name)
-                .filter((name) => name === key).length > 1) {
-                errors.push(`${key} is a reserved field in blocks (block ${blockType})`);
-            }
-        }
-    };
-    const validateRelationField = (field) => {
-        const collectionsSlugs = (config.collections || []).map((c) => c.slug);
-        if (!collectionsSlugs.includes(field.get.relationTo)) {
-            errors.push(`Relation field ${field.name} references unknown collection ${field.get.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
-        }
-    };
-    const validateFields = (fields) => {
-        // Check for field name duplication at this level
-        const duplicates = hasDuplicates(fields.filter(isFormField).map((f) => f.name));
-        if (duplicates.length) {
-            for (const duplicate of duplicates) {
-                errors.push(`Duplicate field '${duplicate}' in ${documentConfig.type} '${documentConfig.slug}'`);
-            }
-        }
-        function validateFieldName(name) {
-            // Regular expression to match
-            // __group_foo__truc, fooBlablaBla, _hello_guys
-            const pattern = /^(_+)?[a-zA-Z][a-zA-Z0-9_]*$/;
-            // Check if string matches pattern and doesn't contain spaces or hyphens
-            return pattern.test(name) && !name.includes('-') && !name.includes(' ');
-        }
-        function validateTabs(field) {
-            const duplicates = hasDuplicates(field.get.tabs.map((t) => t.name));
-            if (duplicates.length) {
-                errors.push(`Dupplicate tab name ${duplicates} in ${documentConfig.slug}`);
-            }
-        }
-        for (const field of fields) {
-            // Recursive check first into Tabs since tabs are not Formfields
-            if (field instanceof TabsBuilder) {
-                validateTabs(field);
-                for (const tab of field.get.tabs) {
-                    validateFields(tab.get.fields);
-                }
-            }
-            // If field is not a Formfield eg. Separator then continue
-            if (!isFormField(field)) {
-                continue;
-            }
-            // Check that a field wich has field._root = true is not localized
-            if (field.get.root && field.get.localized) {
-                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with _root = true, can't be localized`);
-            }
-            // Check for malformed field.name
-            if (!validateFieldName(field.name)) {
-                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
-            }
-            // Recursive check into Blocks
-            if (field instanceof BlocksBuilder) {
-                for (const block of field.get.blocks) {
-                    if (block.name in registeredBlocks) {
-                        const blockDefinedButDiffer = JSON.stringify(registeredBlocks[block.name]) !== JSON.stringify(block);
-                        if (blockDefinedButDiffer) {
-                            errors.push(`Each block with same name should be identique (block ${block.name})`);
-                        }
-                    }
-                    else {
-                        registeredBlocks[block.name] = block;
-                    }
-                    validateFields(block.get.fields.filter(isFormField));
-                    validateBlockField(block.get.fields.filter(isFormField), block.name);
-                }
-                // Recursive check into Tree
-            }
-            else if (field instanceof TreeBuilder) {
-                validateFields(field.get.fields.filter(isFormField));
-                // Recursive check into Tabs
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                validateFields(field.get.fields.filter(isFormField));
-                // Check relation field
-            }
-            else if (field instanceof RelationFieldBuilder) {
-                validateRelationField(field);
-            }
-        }
-    };
-    validateFields(documentConfig.fields);
-    return errors;
-};
-const hasDatabase = (config) => {
-    const hasDatabaseName = '$adapter' in config;
-    if (!hasDatabaseName) {
-        return ['config.$adapter not defined'];
-    }
-    return [];
-};
-function validateAuthCollections(config) {
-    const errors = [];
-    const authCollections = (config.collections || []).filter(isAuthConfig);
-    for (const collection of authCollections) {
-        if (collection.versions) {
-            errors.push(`Auth collections can't be versionned (${collection.slug})`);
-        }
-    }
-    return errors;
-}
-function validate(config) {
-    const validateFunctions = [
-        hasDuplicateSlug,
-        validateSlugs,
-        hasUsersSlug,
-        validateFields,
-        hasDatabase,
-        validateAuthCollections
-    ];
-    for (const isValid of validateFunctions) {
-        const errors = isValid(config);
-        if (errors.length) {
-            cache.clear();
-            errors.map((err) => logger.error(err));
-            return false;
-        }
-    }
-    logger.debug('Config is valid');
-    return true;
-}
-export default validate;

package/dist/core/config/server/write.server.js

@@ -1,77 +0,0 @@
-import { flatten } from 'flat';
-import cache from '../../dev/cache/index.server.js';
-import { CONFIG_DIR } from '../../dev/constants.js';
-/**
- * We actually need to serialize config values that will trigger
- * types, routes, or schema generations, meaning that for now
- * a basic serialization approach is sufficient.
- */
-const serializeValue = (value) => {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-    switch (typeof value) {
-        case 'function':
-            // Handle functions
-            if (Object.prototype.hasOwnProperty.call(value, 'render')) {
-                return `func:${value.name}`;
-            }
-            return `func:${value.toString()}`;
-        case 'object':
-            try {
-                // Builder instances (fields, tabs, blocks, ...) may hold their real state behind
-                // private class fields (e.g. TabBuilder's #tab), invisible to Object.keys()/
-                // JSON.stringify() — flatten() then treats them as leaf objects with zero own keys,
-                // silently serializing as `{}` regardless of actual content. compile() is the same
-                // method already calls to get a plain, fully-resolved representation, so
-                // reuse it here instead of reflecting blindly.
-                if (typeof value.compile === 'function') {
-                    return serializeValue(value.compile());
-                }
-                if (Array.isArray(value)) {
-                    return `array:${JSON.stringify(value)}`;
-                }
-                // Handle Date objects
-                if (value instanceof Date) {
-                    return `date:${value.toISOString()}`;
-                }
-                // Handle regular objects
-                return `object:${JSON.stringify(value)}`;
-            }
-            catch (err) {
-                return `error:${err.message}`;
-            }
-        default:
-            // Handle primitive values
-            return `${typeof value}:${value}`;
-    }
-};
-const writeMemo = (config) => {
-    const memo = flatten(config);
-    // const memoStr = JSON.stringify(config);
-    const memoStr = Object.entries(memo)
-        .map(([key, value]) => {
-        try {
-            const serializedValue = serializeValue(value);
-            return `${key}:${serializedValue}`;
-        }
-        catch (err) {
-            throw new Error(`Config error : Unable to parse value for key ${key}: ${err.message}`);
-        }
-    })
-        // Not part of the user's config object, but generated output (routes, schema, hooks) is
-        // relative to it — a RIME_CONFIG_DIR change must invalidate the memo just like a config
-        // change does, even when the config content itself is byte-identical.
-        .concat(`CONFIG_DIR:${CONFIG_DIR}`)
-        .join('\n');
-    const cached = cache.get('config');
-    if (cached !== memoStr) {
-        cache.set('config', memoStr);
-        return true;
-    }
-    else {
-        return false;
-    }
-};
-export default writeMemo;

package/dist/core/config/shared/augment-icons.d.ts

@@ -1,9 +0,0 @@
-import type { BuiltArea, BuiltCollection } from '../types.js';
-import type { Dic } from '../../../util/types.js';
-import type { Component } from 'svelte';
-export declare const augmentIcons: <const T extends {
-    collections?: BuiltCollection[];
-    areas?: BuiltArea[];
-}>(config: T) => T & {
-    readonly icons: Dic<Component<import("@lucide/svelte").LucideProps, {}, string>>;
-};

package/dist/core/config/shared/augment-icons.js

@@ -1,11 +0,0 @@
-export const augmentIcons = (config) => {
-    const icons = {};
-    // Add icons
-    for (const collection of config.collections || []) {
-        icons[collection.slug] = collection.icon;
-    }
-    for (const area of config.areas || []) {
-        icons[area.slug] = area.icon;
-    }
-    return { ...config, icons };
-};

package/dist/core/config/shared/augment-prototypes.d.ts

@@ -1,8 +0,0 @@
-import type { BuiltArea, BuiltCollection } from '../types.js';
-export declare const augmentPrototypes: <const T extends {
-    collections?: BuiltCollection[];
-    areas?: BuiltArea[];
-}>(config: T) => T & {
-    readonly collections: BuiltCollection[];
-    readonly areas: BuiltArea[];
-};

package/dist/core/config/shared/augment-prototypes.js

@@ -1,7 +0,0 @@
-export const augmentPrototypes = (config) => {
-    return {
-        ...config,
-        collections: config.collections || [],
-        areas: config.areas || []
-    };
-};

package/dist/core/config/shared/compile.d.ts

@@ -1,19 +0,0 @@
-import type { Config } from '../types.js';
-import type { FieldBuilder } from '../../fields/builders/index.js';
-import type { Field } from '../../../types.js';
-import type { WithoutBuilders } from '../../../util/types.js';
-/**
- * Compile fields on the whole config for areaas and collections
- */
-export declare function compileConfig<C extends Config>(config: C): WithoutBuilders<C>;
-/**
- * Compile fields for the given area/collection
- * returns area/collections with compiled fields
- */
-export declare const compileDocumentConfig: <T extends {
-    fields: FieldBuilder[];
-}>(config: T) => WithoutBuilders<T>;
-/**
- * Compile a list of fields and return it
- */
-export declare const compileFields: (fields: FieldBuilder<Field>[]) => Field[];

package/dist/core/config/shared/compile.js

@@ -1,26 +0,0 @@
-/**
- * Compile fields on the whole config for areaas and collections
- */
-export function compileConfig(config) {
-    return {
-        ...config,
-        collections: (config.collections || []).map(compileDocumentConfig),
-        areas: (config.areas || []).map(compileDocumentConfig)
-    };
-}
-/**
- * Compile fields for the given area/collection
- * returns area/collections with compiled fields
- */
-export const compileDocumentConfig = (config) => {
-    return {
-        ...config,
-        fields: compileFields(config.fields)
-    };
-};
-/**
- * Compile a list of fields and return it
- */
-export const compileFields = (fields) => {
-    return fields.map((f) => f.compile());
-};

package/dist/core/config/shared/find-thumbnail.d.ts

@@ -1,9 +0,0 @@
-import type { FieldBuilder } from '../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import type { Field, FormField } from '../../../fields/types.js';
-interface ThumbnailFieldResult {
-    field: FormFieldBuilder<FormField>;
-    path: string;
-}
-export declare function findThumbnailField(fields?: FieldBuilder<Field>[], basePath?: string): ThumbnailFieldResult | null;
-export {};

package/dist/core/config/shared/find-thumbnail.js

@@ -1,34 +0,0 @@
-import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../../fields/group/index.js';
-import { RelationFieldBuilder } from '../../../fields/relation/index.js';
-import { TabsBuilder } from '../../../fields/tabs/index.js';
-export function findThumbnailField(fields = [], basePath = '') {
-    for (const field of fields) {
-        // Direct check for isThumbnail
-        if (field instanceof RelationFieldBuilder &&
-            'isThumbnail' in field.get &&
-            field.get.isThumbnail === true) {
-            const path = basePath ? `${basePath}.${field.name}` : field.name;
-            return { field, path };
-        }
-        // Check in group
-        if (field instanceof GroupFieldBuilder && field.get.fields) {
-            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
-            const found = findThumbnailField(field.get.fields, groupPath);
-            if (found)
-                return found;
-        }
-        // Check in tabs
-        if (field instanceof TabsBuilder && field.get.tabs) {
-            for (const tab of field.get.tabs) {
-                if (tab.get.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
-                    const found = findThumbnailField(tab.get.fields, tabPath);
-                    if (found)
-                        return found;
-                }
-            }
-        }
-    }
-    return null;
-}

package/dist/core/config/shared/find-title.d.ts

@@ -1,14 +0,0 @@
-import type { FieldBuilder } from '../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import type { DateField } from '../../../fields/date/index.js';
-import type { EmailField } from '../../../fields/email/index.js';
-import type { SlugField } from '../../../fields/slug/index.js';
-import type { TextField } from '../../../fields/text/index.js';
-import type { Field, FormField, RichTextField } from '../../../fields/types.js';
-export declare const hasMaybeTitle: (field: Field) => field is TextField | DateField | SlugField | EmailField | RichTextField;
-interface TitleFieldResult {
-    field: FormFieldBuilder<FormField>;
-    path: string;
-}
-export declare function findTitleField(fields?: FieldBuilder<Field>[], basePath?: string): TitleFieldResult | null;
-export {};