@firecms/collection_editor 3.0.1 → 3.1.0-canary.02232f4

package/dist/ui/collection_editor/properties/conditions/EnumConditionsEditor.d.ts

@@ -0,0 +1,6 @@
+import { Properties } from "@firecms/core";
+export interface EnumConditionsEditorProps {
+    disabled: boolean;
+    collectionProperties?: Properties;
+}
+export declare function EnumConditionsEditor({ disabled, collectionProperties }: EnumConditionsEditorProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/collection_editor/properties/conditions/index.d.ts

@@ -0,0 +1,6 @@
+export { ConditionsPanel } from "./ConditionsPanel";
+export { ConditionsEditor } from "./ConditionsEditor";
+export type { ConditionsEditorProps } from "./ConditionsEditor";
+export { EnumConditionsEditor } from "./EnumConditionsEditor";
+export type { EnumConditionsEditorProps } from "./EnumConditionsEditor";
+export { getPropertyPaths, getGroupedPropertyPaths } from "./property_paths";

package/dist/ui/collection_editor/properties/conditions/property_paths.d.ts

@@ -0,0 +1,19 @@
+import { Properties } from "@firecms/core";
+/**
+ * Recursively extract all property paths from a Properties object.
+ * For nested map properties, creates dot-notation paths like "address.city".
+ * Skips PropertyBuilder functions (callbacks) as they cannot be statically analyzed.
+ *
+ * @param properties - The properties object to extract paths from
+ * @param prefix - Optional prefix for nested paths (used in recursion)
+ * @returns Array of property path strings
+ */
+export declare function getPropertyPaths(properties: Properties | undefined, prefix?: string): string[];
+/**
+ * Get property paths grouped by top-level property for UI display.
+ * Skips PropertyBuilder functions.
+ *
+ * @param properties - The properties object
+ * @returns Object with top-level keys mapping to their nested paths
+ */
+export declare function getGroupedPropertyPaths(properties: Properties | undefined): Record<string, string[]>;

package/dist/useCollectionEditorPlugin.d.ts

@@ -4,6 +4,7 @@ import { CollectionEditorPermissionsBuilder } from "./types/config_permissions";
 import { PersistedCollection } from "./types/persisted_collection";
 import { CollectionInference } from "./types/collection_inference";
 import { CollectionsConfigController } from "./types/config_controller";
+import { CollectionGenerationCallback } from "./api/generateCollectionApi";
 export interface CollectionConfigControllerProps<EC extends PersistedCollection = PersistedCollection, USER extends User = User> {
     /**
      * Firebase app where the configuration is saved.
@@ -31,6 +32,11 @@ export interface CollectionConfigControllerProps<EC extends PersistedCollection
     getUser?: (uid: string) => USER | null;
     onAnalyticsEvent?: (event: string, params?: object) => void;
     includeIntroView?: boolean;
+    /**
+     * Callback function for generating/modifying collections.
+     * The plugin is API-agnostic - the consumer provides the implementation.
+     */
+    generateCollection?: CollectionGenerationCallback;
 }
 /**
  * Use this hook to initialise the Collection Editor plugin.
@@ -43,5 +49,5 @@ export interface CollectionConfigControllerProps<EC extends PersistedCollection
  * @param getUser
  * @param collectionInference
  */
-export declare function useCollectionEditorPlugin<EC extends PersistedCollection = PersistedCollection, USER extends User = User>({ collectionConfigController, configPermissions, reservedGroups, extraView, getUser, collectionInference, getData, onAnalyticsEvent, includeIntroView, pathSuggestions }: CollectionConfigControllerProps<EC, USER>): FireCMSPlugin<any, any, PersistedCollection>;
+export declare function useCollectionEditorPlugin<EC extends PersistedCollection = PersistedCollection, USER extends User = User>({ collectionConfigController, configPermissions, reservedGroups, extraView, getUser, collectionInference, getData, onAnalyticsEvent, includeIntroView, pathSuggestions, generateCollection }: CollectionConfigControllerProps<EC, USER>): FireCMSPlugin<any, any, PersistedCollection>;
 export declare function IntroWidget(): import("react/jsx-runtime").JSX.Element | null;

package/dist/utils/validateCollectionJson.d.ts

@@ -0,0 +1,22 @@
+import { EntityCollection } from "@firecms/core";
+/**
+ * Validation error with path and message
+ */
+export interface CollectionValidationError {
+    path: string;
+    message: string;
+}
+/**
+ * Result of collection JSON validation
+ */
+export interface CollectionValidationResult {
+    valid: boolean;
+    errors: CollectionValidationError[];
+    collection?: EntityCollection;
+}
+/**
+ * Validates a JSON string representing a collection configuration.
+ * Returns detailed validation errors if the JSON is invalid or doesn't match
+ * the expected collection schema.
+ */
+export declare function validateCollectionJson(jsonString: string): CollectionValidationResult;

package/package.json

@@ -1,38 +1,38 @@
 {
   "name": "@firecms/collection_editor",
   "type": "module",
-  "version": "3.0.1",
+  "version": "3.1.0-canary.02232f4",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
   "source": "src/index.ts",
   "dependencies": {
-    "@firecms/data_export": "^3.0.1",
-    "@firecms/data_import": "^3.0.1",
-    "@firecms/data_import_export": "^3.0.1",
-    "@firecms/formex": "^3.0.1",
-    "@firecms/schema_inference": "^3.0.1",
-    "@firecms/ui": "^3.0.1",
+    "@firecms/data_export": "^3.1.0-canary.02232f4",
+    "@firecms/data_import": "^3.1.0-canary.02232f4",
+    "@firecms/data_import_export": "^3.1.0-canary.02232f4",
+    "@firecms/formex": "^3.1.0-canary.02232f4",
+    "@firecms/schema_inference": "^3.1.0-canary.02232f4",
+    "@firecms/ui": "^3.1.0-canary.02232f4",
     "json5": "^2.2.3",
     "prism-react-renderer": "^2.4.1"
   },
   "peerDependencies": {
-    "react": ">=18.0.0",
-    "react-dom": ">=18.0.0",
+    "react": ">=18.3.1 || >=19.0.0",
+    "react-dom": ">=18.3.1 || >=19.0.0",
     "react-router": "^6.28.0",
     "react-router-dom": "^6.28.0"
   },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.es.js",
-      "require": "./dist/index.umd.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.umd.js"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
     "dev": "vite",
-    "test": "jest",
+    "test": "jest --passWithNoTests",
     "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
   },
@@ -50,8 +50,8 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
-    "@types/react": "^18.3.24",
-    "@types/react-dom": "^18.3.7",
+    "@types/react": "^19.2.3",
+    "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^4.7.0",
     "babel-plugin-react-compiler": "^19.0.0-beta-af1b7da-20250417",
     "eslint-plugin-react-compiler": "^19.1.0-rc.2",
@@ -69,5 +69,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "72d951d01d15ef5a7efcde6c63839f65964d2f7a"
+  "gitHead": "6281205d9f39f85991e1d8533474bfb9a542ed03"
 }

package/src/ConfigControllerProvider.tsx

@@ -17,6 +17,7 @@ import { CollectionEditorPermissionsBuilder } from "./types/config_permissions";
 import { CollectionInference } from "./types/collection_inference";
 import { PropertyFormDialog } from "./ui/collection_editor/PropertyEditView";
 import { PersistedCollection } from "./types/persisted_collection";
+import { CollectionGenerationCallback } from "./api/generateCollectionApi";
 
 export const ConfigControllerContext = React.createContext<CollectionsConfigController>({} as any);
 export const CollectionEditorContext = React.createContext<CollectionEditorController>({} as any);
@@ -57,21 +58,28 @@ export interface ConfigControllerProviderProps {
 
     onAnalyticsEvent?: (event: string, params?: object) => void;
 
+    /**
+     * Callback function for generating/modifying collections.
+     * The plugin is API-agnostic - the consumer provides the implementation.
+     */
+    generateCollection?: CollectionGenerationCallback;
+
 }
 
 export const ConfigControllerProvider = React.memo(
     function ConfigControllerProvider({
-                                          children,
-                                          collectionConfigController,
-                                          configPermissions,
-                                          reservedGroups,
-                                          collectionInference,
-                                          extraView,
-                                          getUser,
-                                          getData,
-                                          onAnalyticsEvent,
-                                          pathSuggestions
-                                      }: PropsWithChildren<ConfigControllerProviderProps>) {
+        children,
+        collectionConfigController,
+        configPermissions,
+        reservedGroups,
+        collectionInference,
+        extraView,
+        getUser,
+        getData,
+        onAnalyticsEvent,
+        pathSuggestions,
+        generateCollection
+    }: PropsWithChildren<ConfigControllerProviderProps>) {
 
         const navigation = useNavigationController();
         const navigate = useNavigate();
@@ -89,9 +97,12 @@ export const ConfigControllerProvider = React.memo(
                 group?: string,
                 name?: string
             },
+            copyFrom?: PersistedCollection,
             redirect: boolean,
             existingEntities?: Entity<any>[],
             pathSuggestions?: string[];
+            initialView?: "general" | "display" | "properties";
+            expandKanban?: boolean;
         }>();
 
         const [currentPropertyDialog, setCurrentPropertyDialog] = React.useState<{
@@ -104,7 +115,8 @@ export const ConfigControllerProvider = React.memo(
             fullPath?: string,
             parentCollectionIds: string[],
             collectionEditable: boolean;
-            existingEntities?: Entity<any>[]
+            existingEntities?: Entity<any>[];
+            collection?: PersistedCollection;
         }>();
 
         const defaultConfigPermissions: CollectionEditorPermissionsBuilder = useCallback(() => ({
@@ -114,17 +126,21 @@ export const ConfigControllerProvider = React.memo(
         }), []);
 
         const editCollection = ({
-                                    id,
-                                    fullPath,
-                                    parentCollectionIds,
-                                    parentCollection,
-                                    existingEntities
-                                }: {
+            id,
+            fullPath,
+            parentCollectionIds,
+            parentCollection,
+            existingEntities,
+            initialView,
+            expandKanban
+        }: {
             id?: string,
             fullPath?: string,
             parentCollectionIds: string[],
             parentCollection?: PersistedCollection,
-            existingEntities?: Entity<any>[]
+            existingEntities?: Entity<any>[],
+            initialView?: "general" | "display" | "properties",
+            expandKanban?: boolean
         }) => {
             console.debug("Edit collection", id, fullPath, parentCollectionIds, parentCollection);
             onAnalyticsEvent?.("edit_collection", {
@@ -139,19 +155,21 @@ export const ConfigControllerProvider = React.memo(
                 parentCollection,
                 redirect: false,
                 existingEntities,
-                pathSuggestions
+                pathSuggestions,
+                initialView,
+                expandKanban
             });
         };
 
         const editProperty = ({
-                                  propertyKey,
-                                  property,
-                                  editedCollectionId,
-                                  currentPropertiesOrder,
-                                  parentCollectionIds,
-                                  collection,
-                                  existingEntities
-                              }: {
+            propertyKey,
+            property,
+            editedCollectionId,
+            currentPropertiesOrder,
+            parentCollectionIds,
+            collection,
+            existingEntities
+        }: {
             propertyKey?: string,
             property?: Property,
             currentPropertiesOrder?: string[],
@@ -180,17 +198,19 @@ export const ConfigControllerProvider = React.memo(
                 editedCollectionId,
                 parentCollectionIds,
                 collectionEditable: collection?.editable === undefined || collection?.editable === true,
-                existingEntities
+                existingEntities,
+                collection
             });
         };
 
         const createCollection = ({
-                                      parentCollectionIds,
-                                      parentCollection,
-                                      initialValues,
-                                      redirect,
-                                      sourceClick
-                                  }: {
+            parentCollectionIds,
+            parentCollection,
+            initialValues,
+            copyFrom,
+            redirect,
+            sourceClick
+        }: {
             parentCollectionIds: string[],
             parentCollection?: PersistedCollection
             initialValues?: {
@@ -198,6 +218,7 @@ export const ConfigControllerProvider = React.memo(
                 path?: string,
                 name?: string
             },
+            copyFrom?: PersistedCollection,
             redirect: boolean,
             sourceClick?: string
         }) => {
@@ -205,10 +226,11 @@ export const ConfigControllerProvider = React.memo(
                 parentCollectionIds,
                 parentCollection,
                 initialValues,
+                copyFrom,
                 redirect,
                 sourceClick
             });
-            onAnalyticsEvent?.("create_collection", {
+            onAnalyticsEvent?.(copyFrom ? "duplicate_collection" : "create_collection", {
                 parentCollectionIds,
                 parentCollection,
                 initialValues,
@@ -220,6 +242,7 @@ export const ConfigControllerProvider = React.memo(
                 parentCollectionIds,
                 parentCollection,
                 initialValues,
+                copyFrom,
                 redirect,
                 pathSuggestions
             });
@@ -248,6 +271,8 @@ export const ConfigControllerProvider = React.memo(
                         reservedGroups={reservedGroups}
                         extraView={extraView}
                         getUser={getUser}
+                        generateCollection={generateCollection}
+                        onAnalyticsEvent={onAnalyticsEvent}
                         handleClose={(collection) => {
                             if (currentDialog?.redirect) {
                                 if (collection && currentDialog?.isNewCollection && !currentDialog.parentCollectionIds.length) {
@@ -256,7 +281,7 @@ export const ConfigControllerProvider = React.memo(
                                 }
                             }
                             setCurrentDialog(undefined);
-                        }}/>
+                        }} />
 
                     {/* Used for editing properties*/}
                     <PropertyFormDialog
@@ -267,17 +292,27 @@ export const ConfigControllerProvider = React.memo(
                         autoOpenTypeSelect={!currentPropertyDialog ? false : !currentPropertyDialog?.propertyKey}
                         inArray={false}
                         collectionEditable={currentPropertyDialog?.collectionEditable ?? false}
-                        getData={getData && currentPropertyDialog?.editedCollectionId
-                            ? () => {
-                                console.debug("get data for property", currentPropertyDialog?.editedCollectionId);
-                                const resolvedPath = navigation.resolveIdsFrom(currentPropertyDialog.editedCollectionId!)
-                                return getData(resolvedPath, []);
+                        getData={currentPropertyDialog?.existingEntities || (getData && currentPropertyDialog?.editedCollectionId)
+                            ? async () => {
+                                let data: object[] = [];
+                                // First, use existing entities if available (already loaded in table)
+                                if (currentPropertyDialog?.existingEntities) {
+                                    data = currentPropertyDialog.existingEntities.map(e => e.values);
+                                }
+                                // If getData is available and we have a path, also fetch from database
+                                if (getData && currentPropertyDialog?.editedCollectionId) {
+                                    console.debug("Get data for property, path:", currentPropertyDialog?.editedCollectionId);
+                                    const resolvedPath = navigation.resolveIdsFrom(currentPropertyDialog.editedCollectionId!);
+                                    const fetchedData = await getData(resolvedPath, []);
+                                    data.push(...fetchedData);
+                                }
+                                return data;
                             }
                             : undefined}
                         onPropertyChanged={({
-                                                id,
-                                                property
-                                            }) => {
+                            id,
+                            property
+                        }) => {
                             if (!currentPropertyDialog) return;
                             if (!id) return;
                             const newProperty = !(currentPropertyDialog.propertyKey);
@@ -330,11 +365,11 @@ export const ConfigControllerProvider = React.memo(
                         }}
                         initialErrors={{}}
                         forceShowErrors={false}
-                        existingPropertyKeys={[]}
+                        existingPropertyKeys={currentPropertyDialog?.collection?.properties ? Object.keys(currentPropertyDialog.collection.properties) : []}
                         allowDataInference={true}
                         propertyConfigs={propertyConfigs}
                         property={currentPropertyDialog?.property}
-                        propertyKey={currentPropertyDialog?.propertyKey}/>
+                        propertyKey={currentPropertyDialog?.propertyKey} />
 
                 </CollectionEditorContext.Provider>
 

package/src/api/generateCollectionApi.ts

@@ -0,0 +1,119 @@
+import { EntityCollection } from "@firecms/core";
+
+export interface GenerateCollectionRequest {
+    /** User's natural language description of what they want */
+    prompt: string;
+
+    /** Other collections in the project (for context/relationships). Limit to 30. */
+    existingCollections: Partial<EntityCollection>[];
+
+    /** Optional for generate, required for modifications. If provided, modifies this collection */
+    existingCollection?: Partial<EntityCollection>;
+}
+
+/** Operation types for modifying a collection */
+export type CollectionOperationType = "add" | "modify" | "delete";
+
+/** A single operation describing what changed */
+export interface CollectionOperation {
+    op: CollectionOperationType;
+    path: string;
+    value?: any;
+}
+
+/** Result from collection generation, including optional delta operations */
+export interface GenerateCollectionResult {
+    collection: EntityCollection;
+    operations?: CollectionOperation[];
+}
+
+/**
+ * Callback type for generating or modifying a collection.
+ * The plugin is API-agnostic - consumers implement the actual API call.
+ */
+export type CollectionGenerationCallback = (
+    request: GenerateCollectionRequest
+) => Promise<GenerateCollectionResult>;
+
+export class CollectionGenerationApiError extends Error {
+    public code?: string;
+
+    constructor(message: string, code?: string) {
+        super(message);
+        this.code = code;
+        this.name = "CollectionGenerationApiError";
+    }
+}
+
+/**
+ * Default endpoint for AI collection generation
+ */
+export const DEFAULT_COLLECTION_GENERATION_ENDPOINT = "https://api.firecms.co/collections/generate";
+
+/**
+ * Props for building a collection generation callback
+ */
+export interface BuildCollectionGenerationCallbackProps {
+    /**
+     * Function to get the auth token (e.g., from Firebase Auth)
+     * This is typically `authController.getAuthToken` from `@firecms/firebase`
+     */
+    getAuthToken: () => Promise<string>;
+
+    /**
+     * Optional custom API endpoint for collection generation.
+     * Defaults to the FireCMS SaaS API endpoint.
+     */
+    apiEndpoint?: string;
+}
+
+/**
+ * Build a callback for AI collection generation.
+ * This helper allows self-hosted FireCMS users to enable the AI collection
+ * generation feature.
+ *
+ * @example
+ * ```typescript
+ * import { useCollectionEditorPlugin, buildCollectionGenerationCallback } from "@firecms/collection_editor";
+ * import { useFirebaseAuthController } from "@firecms/firebase";
+ *
+ * const authController = useFirebaseAuthController({ firebaseApp });
+ *
+ * const collectionEditorPlugin = useCollectionEditorPlugin({
+ *     // ... other props
+ *     generateCollection: buildCollectionGenerationCallback({
+ *         getAuthToken: authController.getAuthToken
+ *     })
+ * });
+ * ```
+ */
+export function buildCollectionGenerationCallback({
+    getAuthToken,
+    apiEndpoint = DEFAULT_COLLECTION_GENERATION_ENDPOINT
+}: BuildCollectionGenerationCallbackProps): CollectionGenerationCallback {
+    return async (request) => {
+        const token = await getAuthToken();
+        const response = await fetch(apiEndpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`
+            },
+            body: JSON.stringify(request)
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new CollectionGenerationApiError(
+                errorData.error || "Failed to generate collection",
+                errorData.code
+            );
+        }
+
+        const data = await response.json();
+        return {
+            collection: data.data.collection,
+            operations: data.data.operations
+        };
+    };
+}

package/src/api/index.ts

@@ -0,0 +1 @@
+export * from "./generateCollectionApi";

package/src/index.ts

@@ -13,9 +13,14 @@ export {
     editableProperty, removeNonEditableProperties
 } from "./utils/entities";
 export * from "./utils/collections";
+export {
+    validateCollectionJson,
+    type CollectionValidationError,
+    type CollectionValidationResult
+} from "./utils/validateCollectionJson";
 
 export type {
-    CollectionsConfigController, DeleteCollectionParams, SaveCollectionParams, UpdateCollectionParams, CollectionsSetupInfo
+    CollectionsConfigController, DeleteCollectionParams, SaveCollectionParams, UpdateCollectionParams, CollectionsSetupInfo, UpdatePropertiesOrderParams, UpdateKanbanColumnsOrderParams
 } from "./types/config_controller";
 export type {
     CollectionEditorController
@@ -31,6 +36,28 @@ export type {
     CollectionInference
 } from "./types/collection_inference";
 
+export {
+    buildCollectionGenerationCallback,
+    CollectionGenerationApiError,
+    DEFAULT_COLLECTION_GENERATION_ENDPOINT
+} from "./api/generateCollectionApi";
+
+export type {
+    CollectionGenerationCallback,
+    GenerateCollectionRequest,
+    GenerateCollectionResult,
+    CollectionOperation,
+    CollectionOperationType,
+    BuildCollectionGenerationCallbackProps
+} from "./api/generateCollectionApi";
+
 export { MissingReferenceWidget } from "./ui/MissingReferenceWidget";
 
 export * from "./ui/collection_editor/util";
+
+export {
+    PropertyForm,
+    PropertyFormDialog,
+    type PropertyFormProps,
+    type OnPropertyChangedParams
+} from "./ui/collection_editor/PropertyEditView";