@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/relationships/populate-helpers.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Population Helper Functions
+ *
+ * Extracted from the monolithic populate() function to improve
+ * maintainability, testability, and clarity.
+ */
+import type { RevealRequest, TypedFallbackLocale } from '../types/index.js';
+/** Relationship field types supported by population */
+export interface PopulateRelationshipField {
+    type: 'relationship' | 'upload' | 'join';
+    name: string;
+    relationTo?: string | string[];
+    collection?: string | string[];
+    hasMany?: boolean;
+    maxDepth?: number;
+    localized?: boolean;
+}
+/** Information extracted about a relationship */
+export interface RelationInfo {
+    /** The collection slug this relationship points to */
+    relationName: string | undefined;
+    /** The ID(s) to populate */
+    id: unknown;
+    /** The related collection config if available */
+    relatedCollection: unknown;
+}
+/**
+ * Extract relationship information from field and data
+ *
+ * Handles polymorphic relationships, join tables, and direct FK relationships.
+ */
+export declare function extractRelationInfo(field: PopulateRelationshipField, data: unknown, req: {
+    revealui?: {
+        collections?: Record<string, unknown>;
+    };
+}): RelationInfo;
+/**
+ * Check if a relationship should be populated based on depth
+ */
+export declare function shouldPopulateRelationship(currentDepth: number, depth: number): boolean;
+/**
+ * Load a related document using the dataLoader
+ *
+ * Returns the populated document or undefined if not found.
+ */
+export declare function loadRelatedDocument(args: {
+    id: unknown;
+    relationName: string;
+    relatedCollection: unknown;
+    currentDepth: number;
+    depth: number;
+    draft: boolean;
+    fallbackLocale: TypedFallbackLocale;
+    locale: string | null;
+    overrideAccess: boolean;
+    populateArg: unknown;
+    showHiddenFields: boolean;
+    req: {
+        dataLoader?: {
+            load?: (key: string) => Promise<unknown>;
+        };
+    };
+}): Promise<unknown>;
+/**
+ * Recursively populate nested relationships on a document
+ *
+ * Applies afterRead hook to populate relationships within the document.
+ */
+export declare function applyNestedPopulation(args: {
+    doc: unknown;
+    collectionConfig: {
+        slug?: string;
+        fields?: unknown[];
+        defaultPopulate?: unknown;
+    };
+    currentDepth: number;
+    depth: number;
+    draft: boolean;
+    fallbackLocale: TypedFallbackLocale;
+    locale: string | null;
+    overrideAccess: boolean;
+    populateArg: unknown;
+    showHiddenFields: boolean;
+    req: RevealRequest;
+}): Promise<unknown>;
+/**
+ * Location information for updating a document with populated values
+ */
+export interface UpdateLocation {
+    index?: number;
+    key?: string;
+}
+/**
+ * Update document with populated relationship value
+ *
+ * Handles various field configurations: arrays, localized fields, join tables, etc.
+ */
+export declare function updateDocumentWithPopulatedValue(args: {
+    dataReference: Record<string, unknown>;
+    field: PopulateRelationshipField;
+    relationshipValue: unknown;
+    location: UpdateLocation;
+}): void;
+//# sourceMappingURL=populate-helpers.d.ts.map

package/dist/relationships/populate-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate-helpers.d.ts","sourceRoot":"","sources":["../../src/relationships/populate-helpers.ts"],"names":[],"mappings":"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"}

package/dist/relationships/populate-helpers.js

@@ -0,0 +1,187 @@
+/**
+ * Population Helper Functions
+ *
+ * Extracted from the monolithic populate() function to improve
+ * maintainability, testability, and clarity.
+ */
+import { createDataloaderCacheKey } from '../dataloader.js';
+import { afterRead } from '../fields/hooks/afterRead/index.js';
+/**
+ * Extract relationship information from field and data
+ *
+ * Handles polymorphic relationships, join tables, and direct FK relationships.
+ */
+export function extractRelationInfo(field, data, req) {
+    const dataRecord = data;
+    // Determine relation name based on field type
+    let relationName;
+    if (field.type === 'join') {
+        relationName = Array.isArray(field.collection)
+            ? dataRecord.relationTo
+            : field.collection;
+    }
+    else {
+        relationName = Array.isArray(field.relationTo)
+            ? dataRecord.relationTo
+            : field.relationTo;
+    }
+    // Get related collection config
+    const relatedCollection = relationName && req.revealui?.collections ? req.revealui.collections[relationName] : undefined;
+    // Extract ID based on field configuration
+    let id;
+    if (field.type === 'join' && Array.isArray(field.collection)) {
+        id = dataRecord.value;
+    }
+    else if (field.type !== 'join' && Array.isArray(field.relationTo)) {
+        id = dataRecord.value;
+    }
+    else {
+        id = data;
+    }
+    // Normalize ID to string or number
+    if (typeof id !== 'string' &&
+        typeof id !== 'number' &&
+        typeof id?.toString === 'function' &&
+        typeof id !== 'object') {
+        id = id.toString();
+    }
+    return { relationName, id, relatedCollection };
+}
+/**
+ * Check if a relationship should be populated based on depth
+ */
+export function shouldPopulateRelationship(currentDepth, depth) {
+    return depth > 0 && currentDepth <= depth;
+}
+/**
+ * Load a related document using the dataLoader
+ *
+ * Returns the populated document or undefined if not found.
+ */
+export async function loadRelatedDocument(args) {
+    const { id, relationName, relatedCollection, currentDepth, depth, draft, fallbackLocale, locale, overrideAccess, populateArg, showHiddenFields, req, } = args;
+    if (!req.dataLoader?.load) {
+        return undefined;
+    }
+    const relatedCollectionWithConfig = relatedCollection;
+    const collectionConfig = relatedCollectionWithConfig.config || relatedCollectionWithConfig;
+    const collectionSlug = collectionConfig?.slug || relationName;
+    // Load the document via dataLoader
+    const relationshipValue = await req.dataLoader.load(createDataloaderCacheKey({
+        collectionSlug: String(collectionSlug),
+        currentDepth: currentDepth + 1,
+        depth,
+        docID: id,
+        draft,
+        fallbackLocale,
+        locale: locale || 'en',
+        overrideAccess,
+        populate: populateArg || undefined,
+        select: populateArg && typeof populateArg === 'object'
+            ? (populateArg[String(collectionSlug)] ??
+                collectionConfig?.defaultPopulate)
+            : collectionConfig?.defaultPopulate,
+        showHiddenFields,
+        transactionID: '',
+    }));
+    return relationshipValue;
+}
+/**
+ * Recursively populate nested relationships on a document
+ *
+ * Applies afterRead hook to populate relationships within the document.
+ */
+export async function applyNestedPopulation(args) {
+    const { doc, collectionConfig, currentDepth, depth, draft, fallbackLocale, locale, overrideAccess, populateArg, showHiddenFields, req, } = args;
+    if (!doc || currentDepth >= depth) {
+        return doc;
+    }
+    const sanitizedConfig = {
+        ...collectionConfig,
+        flattenedFields: collectionConfig?.fields,
+        customIDType: 'text',
+        trash: false,
+        defaultPopulate: [],
+    };
+    const localeForAfterRead = locale ?? 'en';
+    return await afterRead({
+        collection: sanitizedConfig,
+        context: {},
+        currentDepth: currentDepth + 1,
+        depth,
+        doc: doc,
+        draft,
+        fallbackLocale,
+        findMany: false,
+        flattenLocales: true,
+        global: null,
+        locale: localeForAfterRead,
+        overrideAccess,
+        populate: populateArg || undefined,
+        req,
+        select: undefined,
+        showHiddenFields,
+    });
+}
+/**
+ * Update document with populated relationship value
+ *
+ * Handles various field configurations: arrays, localized fields, join tables, etc.
+ */
+export function updateDocumentWithPopulatedValue(args) {
+    const { dataReference, field, relationshipValue, location } = args;
+    const { index, key } = location;
+    // Case 1: Localized array field (has both index and key)
+    if (typeof index === 'number' && typeof key === 'string') {
+        const fieldRecord = dataReference[field.name];
+        const localeRecords = fieldRecord[key];
+        const localeEntry = localeRecords[index];
+        if (field.type !== 'join' && Array.isArray(field.relationTo)) {
+            localeEntry.value = relationshipValue;
+        }
+        else if (field.type === 'join' && Array.isArray(field.collection)) {
+            localeEntry.value = relationshipValue;
+        }
+        else {
+            localeRecords[index] = relationshipValue;
+        }
+        return;
+    }
+    // Case 2: Array field or localized field (has index or key, but not both)
+    if (typeof index === 'number' || typeof key === 'string') {
+        const fieldRecord = dataReference[field.name];
+        const target = (index ?? key);
+        if (field.type === 'join') {
+            if (!Array.isArray(field.collection)) {
+                const docs = fieldRecord.docs;
+                docs[target] = relationshipValue;
+            }
+            else {
+                const docs = fieldRecord.docs;
+                const docEntry = docs[target];
+                docEntry.value = relationshipValue;
+            }
+        }
+        else if (Array.isArray(field.relationTo)) {
+            const entries = fieldRecord;
+            const entry = entries[target];
+            entry.value = relationshipValue;
+        }
+        else {
+            fieldRecord[target] = relationshipValue;
+        }
+        return;
+    }
+    // Case 3: Single value (no index or key)
+    if (field.type !== 'join' && Array.isArray(field.relationTo)) {
+        const fieldRecord = dataReference[field.name];
+        fieldRecord.value = relationshipValue;
+    }
+    else if (field.type === 'join' && Array.isArray(field.collection)) {
+        const fieldRecord = dataReference[field.name];
+        fieldRecord.value = relationshipValue;
+    }
+    else {
+        dataReference[field.name] = relationshipValue;
+    }
+}

package/dist/relationships/population.d.ts

@@ -0,0 +1,42 @@
+import type { PopulateType, TypedFallbackLocale } from '../types/index.js';
+interface PopulateRequest {
+    revealui?: {
+        collections?: Record<string, {
+            config?: {
+                defaultPopulate?: unknown;
+            };
+        }>;
+        config?: {
+            collections?: unknown[];
+        };
+    };
+    dataLoader?: {
+        load?: (key: string) => Promise<unknown>;
+        find?: (options: unknown) => Promise<unknown>;
+    };
+}
+interface PopulateRelationshipField {
+    type: 'relationship' | 'upload' | 'join';
+    name: string;
+    relationTo?: string | string[];
+    collection?: string | string[];
+    hasMany?: boolean;
+    maxDepth?: number;
+    localized?: boolean;
+}
+type PromiseArgs = {
+    currentDepth: number;
+    depth: number;
+    draft: boolean;
+    fallbackLocale: TypedFallbackLocale;
+    field: PopulateRelationshipField;
+    locale: null | string;
+    overrideAccess: boolean;
+    populate?: PopulateType;
+    req: PopulateRequest;
+    showHiddenFields: boolean;
+    siblingDoc: Record<string, unknown>;
+};
+export declare const relationshipPopulationPromise: ({ currentDepth, depth, draft, fallbackLocale, field, locale, overrideAccess, populate: populateArg, req, showHiddenFields, siblingDoc, }: PromiseArgs) => Promise<void>;
+export {};
+//# sourceMappingURL=population.d.ts.map

package/dist/relationships/population.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"population.d.ts","sourceRoot":"","sources":["../../src/relationships/population.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAiB,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAGzF,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE;QACT,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,CAAC,EAAE;gBAAE,eAAe,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;SAAE,CAAC,CAAA;QACxE,MAAM,CAAC,EAAE;YAAE,WAAW,CAAC,EAAE,OAAO,EAAE,CAAA;SAAE,CAAA;KACrC,CAAA;IACD,UAAU,CAAC,EAAE;QACX,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QACxC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;KAC9C,CAAA;CACF;AAGD,UAAU,yBAAyB;IACjC,IAAI,EAAE,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAA;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAkID,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,mBAAmB,CAAA;IACnC,KAAK,EAAE,yBAAyB,CAAA;IAChC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;IACrB,cAAc,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,GAAG,EAAE,eAAe,CAAA;IACpB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC,CAAA;AAED,eAAO,MAAM,6BAA6B,GAAU,0IAYjD,WAAW,KAAG,OAAO,CAAC,IAAI,CAoI5B,CAAA"}

package/dist/relationships/population.js

@@ -0,0 +1,188 @@
+import { fieldHasMaxDepth, fieldShouldBeLocalized, fieldSupportsMany, } from '../fields/config/types.js';
+/**
+ * Populate a single relationship field
+ *
+ * Refactored from the original monolithic function for better maintainability.
+ * Uses helper functions from populate-helpers.ts for clarity and testability.
+ */
+const populate = async ({ currentDepth, data, dataReference, depth, draft, fallbackLocale, field, index, key, locale, overrideAccess, populateArg, req, showHiddenFields, }) => {
+    // Import helpers (dynamic to avoid circular dependencies)
+    const { extractRelationInfo, shouldPopulateRelationship, loadRelatedDocument, applyNestedPopulation, updateDocumentWithPopulatedValue, } = await import('./populate-helpers.js');
+    // Step 1: Extract relationship information
+    const { relationName, id, relatedCollection } = extractRelationInfo(field, data, req);
+    if (!relatedCollection) {
+        return; // No collection to populate from
+    }
+    // Step 2: Check if we should populate
+    let relationshipValue;
+    if (shouldPopulateRelationship(currentDepth, depth) && req.dataLoader?.load) {
+        const collectionConfig = relatedCollection.config || relatedCollection;
+        // Step 3: Load the related document
+        relationshipValue = await loadRelatedDocument({
+            id,
+            relationName: relationName || collectionConfig.slug || '',
+            relatedCollection,
+            currentDepth,
+            depth,
+            draft,
+            fallbackLocale,
+            locale,
+            overrideAccess,
+            populateArg,
+            showHiddenFields,
+            req,
+        });
+        // Step 4: Recursively populate nested relationships
+        if (relationshipValue && currentDepth < depth) {
+            relationshipValue = await applyNestedPopulation({
+                doc: relationshipValue,
+                collectionConfig,
+                currentDepth,
+                depth,
+                draft,
+                fallbackLocale,
+                locale,
+                overrideAccess,
+                populateArg,
+                showHiddenFields,
+                req: req,
+            });
+        }
+    }
+    // Step 5: Fall back to ID if no value loaded
+    if (!relationshipValue) {
+        relationshipValue = id;
+    }
+    // Step 6: Update the document with the populated value
+    updateDocumentWithPopulatedValue({
+        dataReference,
+        field,
+        relationshipValue,
+        location: { index, key },
+    });
+};
+export const relationshipPopulationPromise = async ({ currentDepth, depth, draft, fallbackLocale, field, locale, overrideAccess, populate: populateArg, req, showHiddenFields, siblingDoc, }) => {
+    const resultingDoc = siblingDoc;
+    const fieldForChecks = field;
+    const maxDepth = fieldHasMaxDepth(fieldForChecks) ? field.maxDepth : undefined;
+    const populateDepth = maxDepth !== undefined && maxDepth < depth ? maxDepth : depth;
+    const rowPromises = [];
+    const siblingFieldValue = siblingDoc[field.name];
+    const siblingFieldRecord = typeof siblingFieldValue === 'object' && siblingFieldValue !== null
+        ? siblingFieldValue
+        : null;
+    if (field.type === 'join' || (fieldSupportsMany(fieldForChecks) && field.hasMany)) {
+        if (fieldShouldBeLocalized({ field: fieldForChecks, parentIsLocalized: false }) &&
+            locale === 'all' &&
+            siblingFieldRecord) {
+            Object.keys(siblingFieldRecord).forEach((localeKey) => {
+                const localeValue = siblingFieldRecord[localeKey];
+                if (Array.isArray(localeValue)) {
+                    const localeValues = localeValue;
+                    localeValues.forEach((_, index) => {
+                        const rowPromise = async () => {
+                            await populate({
+                                currentDepth,
+                                data: localeValues[index],
+                                dataReference: resultingDoc,
+                                depth: populateDepth,
+                                draft,
+                                fallbackLocale,
+                                field,
+                                index,
+                                key: localeKey,
+                                locale,
+                                overrideAccess,
+                                populateArg: populateArg || undefined,
+                                req,
+                                showHiddenFields,
+                            });
+                        };
+                        rowPromises.push(rowPromise());
+                    });
+                }
+            });
+        }
+        else if (Array.isArray(siblingFieldValue) ||
+            Array.isArray(siblingFieldRecord?.docs) ||
+            Array.isArray(siblingDoc[`${field.name}_ids`])) {
+            const docsValue = siblingFieldRecord?.docs;
+            const idsValue = siblingDoc[`${field.name}_ids`];
+            const relationshipArray = Array.isArray(siblingFieldValue)
+                ? siblingFieldValue
+                : Array.isArray(docsValue)
+                    ? docsValue
+                    : idsValue;
+            relationshipArray.forEach((relatedDoc, index) => {
+                const rowPromise = async () => {
+                    if (relatedDoc) {
+                        const relatedDocRecord = typeof relatedDoc === 'object' && relatedDoc !== null
+                            ? relatedDoc
+                            : null;
+                        const relatedId = relatedDocRecord?.id;
+                        await populate({
+                            currentDepth,
+                            data: !(field.type === 'join' && Array.isArray(field.collection)) && relatedId
+                                ? relatedId
+                                : relatedDoc,
+                            dataReference: resultingDoc,
+                            depth: populateDepth,
+                            draft,
+                            fallbackLocale,
+                            field,
+                            index,
+                            locale,
+                            overrideAccess,
+                            populateArg: populateArg || undefined,
+                            req,
+                            showHiddenFields,
+                        });
+                    }
+                };
+                rowPromises.push(rowPromise());
+            });
+        }
+    }
+    else if (field.localized && locale === 'all' && siblingFieldRecord) {
+        Object.keys(siblingFieldRecord).forEach((localeKey) => {
+            const rowPromise = async () => {
+                await populate({
+                    currentDepth,
+                    data: siblingFieldRecord[localeKey],
+                    dataReference: resultingDoc,
+                    depth: populateDepth,
+                    draft,
+                    fallbackLocale,
+                    field,
+                    key: localeKey,
+                    locale,
+                    overrideAccess,
+                    populateArg: populateArg || undefined,
+                    req,
+                    showHiddenFields,
+                });
+            };
+            rowPromises.push(rowPromise());
+        });
+        await Promise.all(rowPromises);
+    }
+    else if (siblingFieldValue || siblingDoc[`${field.name}_id`]) {
+        // For relationships, the data might be in the FK column
+        const relationshipData = siblingFieldValue || siblingDoc[`${field.name}_id`];
+        await populate({
+            currentDepth,
+            data: relationshipData,
+            dataReference: resultingDoc,
+            depth: populateDepth,
+            draft,
+            fallbackLocale,
+            field,
+            locale,
+            overrideAccess,
+            populateArg: populateArg || undefined,
+            req,
+            showHiddenFields,
+        });
+    }
+    await Promise.all(rowPromises);
+};

package/dist/revealui.d.ts

@@ -0,0 +1,46 @@
+/**
+ * RevealUI Core Implementation
+ *
+ * Main entry point that re-exports from organized modules.
+ */
+export { RevealUICollection } from './collections/CollectionOperations.js';
+export { RevealUIGlobal } from './globals/GlobalOperations.js';
+export { createLogger, defaultLogger, Logger, type RevealUILogger, } from './instance/logger.js';
+export { createRevealUIInstance } from './instance/RevealUIInstance.js';
+export { buildWhereClause, extractWhereValues, } from './queries/queryBuilder.js';
+export { getRelationshipFields, validateRelationshipMetadata, } from './relationships/analyzer.js';
+export { relationshipPopulationPromise } from './relationships/population.js';
+export { flattenResult } from './utils/flattenResult.js';
+import type { RevealUITraverseFieldsArgs, RevealUITraverseFieldsResult } from './types/index.js';
+export declare function afterChangeTraverseFields(args: RevealUITraverseFieldsArgs): Promise<RevealUITraverseFieldsResult>;
+export declare function afterReadTraverseFields(args: RevealUITraverseFieldsArgs): Promise<RevealUITraverseFieldsResult>;
+export declare function beforeChangeTraverseFields(args: RevealUITraverseFieldsArgs): Promise<RevealUITraverseFieldsResult>;
+export declare function beforeValidateTraverseFields(args: RevealUITraverseFieldsArgs): Promise<RevealUITraverseFieldsResult>;
+import type { RevealUIDependencyCheckArgs } from './types/index.js';
+export declare function checkDependencies(args: RevealUIDependencyCheckArgs): boolean;
+/**
+ * @deprecated Use deepMerge from '@revealui/core/config/utils' or '@revealui/core' instead
+ * This function is kept for backward compatibility but will be removed in a future version.
+ */
+export declare function deepMergeSimple<T extends Record<string, unknown>>(target: T, source: Partial<T>): T;
+import type { JSONSchema4TypeName } from 'json-schema';
+import type React from 'react';
+import type { RevealUIBlock, RevealUIEnhancedField, RevealUIField, RevealUIRichTextAdapter } from './types/index.js';
+export type { Field, RevealUIField, SanitizedConfig } from './types/index.js';
+export type StaticLabel = string;
+export type ServerFieldBase = RevealUIField;
+export type RichTextAdapter = RevealUIRichTextAdapter;
+export type RichTextField = RevealUIEnhancedField;
+export type Data = Record<string, unknown>;
+export type FormState = Record<string, unknown>;
+export type { CollectionConfig, Config, GlobalConfig } from './types/index.js';
+export type BlocksFieldClient = React.ComponentType<Record<string, unknown>>;
+export type ClientBlock = React.ComponentType<Record<string, unknown>>;
+export type CodeFieldClient = React.ComponentType<Record<string, unknown>>;
+export type CodeFieldClientProps = Record<string, unknown>;
+export type BlocksField = RevealUIField;
+export type Block = RevealUIBlock;
+export type BlockJSX = React.ReactElement;
+export type BlockSlug = string;
+export declare function withNullableJSONSchemaType(typeName: JSONSchema4TypeName, isRequired: boolean): JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
+//# sourceMappingURL=revealui.d.ts.map

package/dist/revealui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revealui.d.ts","sourceRoot":"","sources":["../src/revealui.ts"],"names":[],"mappings":"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"}

package/dist/revealui.js

@@ -0,0 +1,92 @@
+/**
+ * RevealUI Core Implementation
+ *
+ * Main entry point that re-exports from organized modules.
+ */
+// Collection and Global operations
+export { RevealUICollection } from './collections/CollectionOperations.js';
+export { RevealUIGlobal } from './globals/GlobalOperations.js';
+// Logger
+export { createLogger, defaultLogger, Logger, } from './instance/logger.js';
+// Main instance creation
+export { createRevealUIInstance } from './instance/RevealUIInstance.js';
+// Query utilities
+export { buildWhereClause, extractWhereValues, } from './queries/queryBuilder.js';
+// Relationship utilities
+export { getRelationshipFields, validateRelationshipMetadata, } from './relationships/analyzer.js';
+export { relationshipPopulationPromise } from './relationships/population.js';
+// Utilities
+export { flattenResult } from './utils/flattenResult.js';
+import { traverseFieldsCore } from './fieldTraversal.js';
+export async function afterChangeTraverseFields(args) {
+    // Traverse fields after changes have been made
+    // This allows post-processing, side effects, and cleanup
+    return traverseFieldsCore(args, 'afterChange');
+}
+export async function afterReadTraverseFields(args) {
+    // Traverse fields after data has been read from the database
+    // This allows formatting, transformation, and relationship population
+    return traverseFieldsCore(args, 'afterRead');
+}
+export async function beforeChangeTraverseFields(args) {
+    // Traverse fields before changes are applied
+    // This allows validation, transformation, and default value assignment
+    return traverseFieldsCore(args, 'beforeChange');
+}
+export async function beforeValidateTraverseFields(args) {
+    // Traverse fields before validation runs
+    // This allows data preparation, type coercion, and required field checks
+    return traverseFieldsCore(args, 'beforeValidate');
+}
+export function checkDependencies(args) {
+    const { field } = args;
+    // Check for conditional fields (fields that depend on other fields via admin.condition)
+    if ('admin' in field &&
+        field.admin &&
+        typeof field.admin === 'object' &&
+        'condition' in field.admin) {
+        const condition = field.admin.condition;
+        // If condition is a function, we can't evaluate it without data
+        // Return true to allow the field to be processed (validation will happen later with data)
+        if (typeof condition === 'function') {
+            // Condition functions require data to evaluate, so we can't check dependencies here
+            // This is acceptable - conditions are evaluated at runtime when data is available
+            return true;
+        }
+        // If condition is a boolean or other simple type, evaluate it directly
+        if (typeof condition === 'boolean') {
+            return condition;
+        }
+    }
+    // Check for relationship dependencies
+    if (field.type === 'relationship' || field.type === 'upload') {
+        // Validate that relationTo is specified
+        if ('relationTo' in field && field.relationTo) {
+            const relationTo = field.relationTo;
+            const targetCollections = Array.isArray(relationTo) ? relationTo : [relationTo];
+            // Basic validation: ensure we have at least one target collection
+            // In a full implementation, we'd check if the collections exist in the config
+            return (targetCollections.length > 0 &&
+                targetCollections.every((coll) => typeof coll === 'string' && coll.length > 0));
+        }
+        // Relationship field without relationTo is invalid
+        return false;
+    }
+    // No dependencies found or all dependencies are valid
+    return true;
+}
+// Deep merge utility - re-exported from config/utils for convenience
+import { deepMerge as coreDeepMerge } from './config/utils.js';
+/**
+ * @deprecated Use deepMerge from '@revealui/core/config/utils' or '@revealui/core' instead
+ * This function is kept for backward compatibility but will be removed in a future version.
+ */
+export function deepMergeSimple(target, source) {
+    // Use the canonical deepMerge implementation from config/utils
+    return coreDeepMerge(target, source);
+}
+// JSON Schema utility
+export function withNullableJSONSchemaType(typeName, isRequired) {
+    // Return the type name, or an array including null if not required
+    return isRequired ? typeName : [typeName, 'null'];
+}