@rebasepro/admin 0.6.0 → 0.7.0

package/src/hooks/navigation/useResolvedViews.tsx

@@ -1,6 +1,6 @@
 
 import type { AppView, AppViewsBuilder, EffectiveRoleController, RebasePlugin } from "@rebasepro/types";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useMemo, useRef } from "react";
 
 /**
  * Compare two view arrays by their slug identity.
@@ -20,6 +20,7 @@ function viewSlugsEqual(a: AppView[] | undefined, b: AppView[] | undefined): boo
 import type { AuthController, RebaseData, User } from "@rebasepro/types";
 
 import { resolveAppViews } from "./useNavigationResolution";
+import { useAsyncResolver } from "./useAsyncResolver";
 
 export type UseResolvedViewsProps<USER extends User> = {
     authController: AuthController<USER>;
@@ -39,6 +40,23 @@ export type UseResolvedViewsResult = {
     refresh: () => void;
 };
 
+/**
+ * Combined result type for the async resolver — holds both views and
+ * adminViews so they can be resolved together in a single async call.
+ */
+type ResolvedViewsData = {
+    views: AppView[] | undefined;
+    adminViews: AppView[] | undefined;
+};
+
+/**
+ * Equality check for the combined views data.
+ * Compares both views and adminViews by slug identity.
+ */
+function areResolvedViewsEqual(a: ResolvedViewsData, b: ResolvedViewsData): boolean {
+    return viewSlugsEqual(a.views, b.views) && viewSlugsEqual(a.adminViews, b.adminViews);
+}
+
 /**
  * Hook that resolves view and admin view props (which may be async builders or arrays)
  * into concrete AppView[].
@@ -60,21 +78,11 @@ export function useResolvedViews<USER extends User>(
         effectiveRoleController
     } = props;
 
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState<Error | undefined>(undefined);
-    const [resolvedViews, setResolvedViews] = useState<AppView[] | undefined>(undefined);
-    const [resolvedAdminViews, setResolvedAdminViews] = useState<AppView[] | undefined>(undefined);
-
-    // Track the trigger count to allow force-refresh
-    const [refreshTrigger, setRefreshTrigger] = useState(0);
-
-    const refresh = useCallback(() => {
-        setRefreshTrigger(prev => prev + 1);
-    }, []);
-
-    // Refs for change-detection (avoids state updates when views haven't changed)
-    const viewsRef = useRef<AppView[] | undefined>(undefined);
-    const adminViewsRef = useRef<AppView[] | undefined>(undefined);
+    // Stable identity string for the user — avoids re-triggering when the
+    // authController object reference changes but uid/roles are the same.
+    const userIdentity = authController.user
+        ? `${authController.user.uid}:${(authController.user.roles ?? []).sort().join(',')}`
+        : null;
 
     // Use refs for values that may be new objects each render but shouldn't
     // re-trigger the effect. The effect reads them at execution time.
@@ -104,64 +112,26 @@ export function useResolvedViews<USER extends User>(
     resolvedAuthControllerRef.current = resolvedAuthController;
 
     const initialLoading = resolvedAuthController.initialLoading;
-    const user = resolvedAuthController.user;
-
-    useEffect(() => {
-        if (initialLoading) return;
-
-        let cancelled = false;
-
-        (async () => {
-            try {
-                const [newViews, newAdminViews] = await Promise.all([
-                    resolveAppViews(viewsProp, resolvedAuthControllerRef.current, dataRef.current, pluginsRef.current),
-                    resolveAppViews(adminViewsProp, resolvedAuthControllerRef.current, dataRef.current)
-                ]);
-
-                // Compare views by slug identity rather than deepEqual.
-                // Views contain React elements (JSX) whose internal properties
-                // change on every render, making deepEqual unreliable.
-                if (!viewSlugsEqual(viewsRef.current, newViews)) {
-                    viewsRef.current = newViews;
-                    setResolvedViews(newViews);
-                }
 
-                if (!viewSlugsEqual(adminViewsRef.current, newAdminViews)) {
-                    adminViewsRef.current = newAdminViews;
-                    setResolvedAdminViews(newAdminViews);
-                }
-
-                setError(undefined);
-            } catch (e) {
-                if (!cancelled) {
-                    console.error("Error resolving views:", e);
-                    setError(e as Error);
-                }
-            } finally {
-                if (!cancelled) {
-                    setLoading(false);
-                }
-            }
-        })();
-
-        return () => {
-            cancelled = true;
-        };
-    }, [
-        viewsProp,
-        adminViewsProp,
-        refreshTrigger,
-        adminMode,
-        initialLoading,
-        user
-    ]);
+    const { data: resolvedData, loading, error, refresh } = useAsyncResolver<ResolvedViewsData>({
+        resolver: async () => {
+            const [newViews, newAdminViews] = await Promise.all([
+                resolveAppViews(viewsProp, resolvedAuthControllerRef.current, dataRef.current, pluginsRef.current),
+                resolveAppViews(adminViewsProp, resolvedAuthControllerRef.current, dataRef.current)
+            ]);
+            return { views: newViews, adminViews: newAdminViews };
+        },
+        initialValue: { views: undefined, adminViews: undefined },
+        isEqual: areResolvedViewsEqual,
+        deps: [viewsProp, adminViewsProp, adminMode, userIdentity],
+        disabled: initialLoading,
+    });
 
     return useMemo(() => ({
-        views: resolvedViews,
-        adminViews: resolvedAdminViews,
+        views: resolvedData.views,
+        adminViews: resolvedData.adminViews,
         loading,
         error,
         refresh
-    }), [resolvedViews, resolvedAdminViews, loading, error, refresh]);
+    }), [resolvedData, loading, error, refresh]);
 }
-

package/src/hooks/navigation/useTopLevelNavigation.ts

@@ -16,7 +16,7 @@ export type UseTopLevelNavigationProps = {
     viewsOrder?: string[];
     urlController: UrlController;
     adminMode?: "content" | "studio" | "settings";
-    collectionRegistryController: CollectionRegistryController<any> & { collectionRegistryRef: React.MutableRefObject<CollectionRegistry> };
+    collectionRegistryController: CollectionRegistryController & { collectionRegistryRef: React.MutableRefObject<CollectionRegistry> };
 };
 
 export type UseTopLevelNavigationResult = {
@@ -178,26 +178,30 @@ export function useTopLevelNavigation(
         ];
 
         const groupOrderValue = (groupName?: string): number => {
-            if (groupName === NAVIGATION_ADMIN_GROUP_NAME) return 1;
+            if (groupName === NAVIGATION_ADMIN_GROUP_NAME || groupName === "Settings" || groupName === "Admin") return 1;
             return 0;
         };
 
+        const usedViewsOrder = viewsOrder ?? navigationEntriesOrder;
         navigationEntries = navigationEntries.sort((a, b) => {
-            return groupOrderValue(a.group) - groupOrderValue(b.group);
-        });
+            // Primary: group priority (admin/settings last)
+            const groupDiff = groupOrderValue(a.group) - groupOrderValue(b.group);
+            if (groupDiff !== 0) return groupDiff;
 
-        const usedViewsOrder = viewsOrder ?? navigationEntriesOrder;
-        if (usedViewsOrder) {
-            navigationEntries = navigationEntries.sort((a, b) => {
+            // Secondary: explicit view order (if provided)
+            if (usedViewsOrder) {
                 const getSortPath = (navEntry: NavigationEntry) => typeof navEntry.slug === "string" ? navEntry.slug : navEntry.slug[0];
                 const aIndex = usedViewsOrder.indexOf(getSortPath(a));
                 const bIndex = usedViewsOrder.indexOf(getSortPath(b));
-                if (aIndex === -1 && bIndex === -1) return 0;
-                if (aIndex === -1) return 1;
-                if (bIndex === -1) return -1;
-                return aIndex - bIndex;
-            });
-        }
+                if (aIndex !== -1 || bIndex !== -1) {
+                    if (aIndex === -1) return 1;
+                    if (bIndex === -1) return -1;
+                    return aIndex - bIndex;
+                }
+            }
+
+            return 0;
+        });
 
         const collectedGroupsFromEntries = navigationEntries
             .map(e => e.group)
@@ -213,9 +217,9 @@ export function useTopLevelNavigation(
         ];
 
         const uniqueGroupsArray = [...new Set(allDefinedGroups)];
-        const adminGroups = uniqueGroupsArray.filter(g => g === NAVIGATION_ADMIN_GROUP_NAME);
-        const nonAdminGroups = uniqueGroupsArray.filter(g => g !== NAVIGATION_ADMIN_GROUP_NAME);
-        const uniqueGroups = [...nonAdminGroups, ...adminGroups] as string[];
+        const lastGroups = uniqueGroupsArray.filter(g => g === NAVIGATION_ADMIN_GROUP_NAME || g === "Settings" || g === "Admin");
+        const otherGroups = uniqueGroupsArray.filter(g => g !== NAVIGATION_ADMIN_GROUP_NAME && g !== "Settings" && g !== "Admin");
+        const uniqueGroups = [...otherGroups, ...lastGroups] as string[];
 
         const computedTopLevelNav = {
             allowDragAndDrop: plugins?.some((plugin: RebasePlugin) => plugin.hooks?.allowDragAndDrop) ?? false,

package/src/hooks/navigation/utils.ts

@@ -1,12 +1,12 @@
 import type { AppView, EntityCollection, RebasePlugin, NavigationGroupMapping } from "@rebasepro/types";
-;
+
 import { getSubcollections } from "@rebasepro/common";
 import { deepEqual as equal } from "fast-equals";
 
 export const NAVIGATION_DEFAULT_GROUP_NAME = "Views";
 export const NAVIGATION_ADMIN_GROUP_NAME = "Admin";
 
-export function getGroup(collectionOrView: EntityCollection<any, any> | AppView) {
+export function getGroup(collectionOrView: EntityCollection | AppView) {
     const trimmed = collectionOrView.group?.trim();
     if (!trimmed || trimmed === "") {
         return NAVIGATION_DEFAULT_GROUP_NAME;
@@ -28,8 +28,11 @@ export function computeNavigationGroups({
 
     // Deep clone the input groups upfront to avoid mutating the caller's data
     let result = navigationGroupMappings
-        ? navigationGroupMappings.map(g => ({ name: g.name,
-entries: [...g.entries] }))
+        ? navigationGroupMappings.map(g => ({
+            name: g.name,
+            entries: [...g.entries],
+            ...(g.collapsedByDefault !== undefined && { collapsedByDefault: g.collapsedByDefault })
+        }))
         : navigationGroupMappings;
 
     // Merge plugin navigation entries

package/src/index.ts

@@ -1,8 +1,8 @@
 // CMS-specific types take priority over base types when names conflict
 export * from "./types";
-// Editor types only — the full ProseMirror editor is a heavy import (~300 KB)
+// Editor types only — the full ProseMirror editor (RichTextEditor) is a heavy import (~300 KB)
 // and is available as a separate entry point: @rebasepro/admin/editor
-export type { RebaseEditorProps, JSONContent, EditorAIController } from "./editor";
+export type { RichTextEditorProps, RichTextEditorTextSize, RebaseEditorProps, RebaseEditorTextSize, JSONContent, EditorAIController } from "./editor";
 export * from "./form";
 export * from "./preview";
 export * from "./routes";
@@ -92,6 +92,11 @@ export {
     getEntityTitlePropertyKey
 } from "./util";
 
+// Headless collection view adapters
+// Map entity types to the data-agnostic CollectionView from @rebasepro/ui
+export { mapPropertyToConfig, mapPropertiesToConfigs } from "./util/propertyConfigMapper";
+export { useCollectionDataController, createStaticDataController } from "./util/dataControllerAdapter";
+
 // Data import/export — merged from former standalone packages
 export * from "./data_import";
 export * from "./data_export";

package/src/routes/CustomViewRoute.tsx

@@ -1,8 +1,6 @@
+import React, { useEffect, useRef } from "react";
 import type { AppView } from "@rebasepro/types";
-;
-import { useEffect } from "react";
-import { useBreadcrumbsController } from "../index";
-import { useUrlController } from "../index";
+import { useBreadcrumbsController, useUrlController } from "../index";
 
 export function CustomViewRoute({ view }: {
     view: AppView
@@ -11,8 +9,14 @@ export function CustomViewRoute({ view }: {
     const breadcrumbs = useBreadcrumbsController();
     const urlController = useUrlController();
 
+    // Use a ref to avoid breadcrumbs identity in the dep array —
+    // breadcrumbs.set() creates a new context value each call, which would
+    // re-trigger this effect and cause an infinite render loop.
+    const breadcrumbsRef = useRef(breadcrumbs);
+    breadcrumbsRef.current = breadcrumbs;
+
     useEffect(() => {
-        breadcrumbs.set({
+        breadcrumbsRef.current.set({
             breadcrumbs: [{
                 title: view.name,
                 url: urlController.buildAppUrlPath(view.slug)
@@ -20,5 +24,9 @@ export function CustomViewRoute({ view }: {
         });
     }, [view.slug, urlController]);
 
-    return view.view;
+    if (typeof view.view === 'function') {
+        const ViewComponent = view.view;
+        return <ViewComponent />;
+    }
+    return <>{view.view}</>;
 }

package/src/types/components/EntityFormActionsProps.tsx

@@ -13,7 +13,7 @@ export interface EntityFormActionsProps {
     disabled: boolean;
     status: "new" | "existing" | "copy";
     pluginActions: React.ReactNode[];
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     showDefaultActions?: boolean;
     navigateBack: () => void;
     formContext: FormContext

package/src/types/components/EntityFormProps.tsx

@@ -4,6 +4,11 @@ import { FormContext } from "../fields";
 import { FormexController } from "./formex";
 import { EntityFormActionsProps } from "./EntityFormActionsProps";
 
+/**
+ * Props for the headless EntityForm component.
+ * This form can be used without CMS context — all backend concerns
+ * (save, caching, analytics, plugin slots) are provided via callbacks.
+ */
 export type EntityFormProps<M extends Record<string, unknown>> = {
     path: string;
     fullIdPath?: string;
@@ -44,6 +49,69 @@ export type EntityFormProps<M extends Record<string, unknown>> = {
     Builder?: React.ComponentType<EntityCustomViewParams<M>>;
 
     children?: React.ReactNode;
+
+    // --- Headless callbacks (replace internal CMS hooks) ---
+
+    /**
+     * Called on form submit with the values to save.
+     * The EntityFormBinding wrapper provides this automatically.
+     * When using EntityForm standalone, provide your own save logic.
+     */
+    onSubmit?: (values: M, formex: FormexController<M>) => Promise<Entity<M> | void> | void;
+
+    /**
+     * Called when form values change (deferred).
+     * The EntityFormBinding wrapper uses this for entity caching.
+     */
+    onValuesChangeDeferred?: (values: M, controller: FormexController<M>) => void;
+
+    /**
+     * Called when the form is reset.
+     */
+    onReset?: () => void;
+
+    /**
+     * Validate that a field value is unique.
+     * The EntityFormBinding wrapper provides this via the data layer.
+     */
+    uniqueFieldValidator?: (params: { name: string; value: unknown }) => Promise<boolean>;
+
+    // --- Slots (replace useSlot) ---
+
+    /** Content rendered before the form fields */
+    beforeFields?: React.ReactNode;
+    /** Content rendered after the form fields */
+    afterFields?: React.ReactNode;
+    /** Plugin-provided action elements */
+    pluginActions?: React.ReactNode[];
+
+    // --- Local changes (managed externally in binding) ---
+
+    /**
+     * Initial values for the form, after applying local changes.
+     * If not provided, computed from entity + collection defaults.
+     */
+    computedInitialValues?: Partial<M>;
+    /**
+     * Whether there are unsaved local changes in the cache.
+     */
+    hasLocalChanges?: boolean;
+    /**
+     * The local changes data for the manual-apply menu.
+     */
+    localChangesData?: Partial<M>;
+    /**
+     * Whether manual-apply local changes mode is enabled.
+     */
+    manualApplyLocalChanges?: boolean;
+    /**
+     * Cache key for the local changes menu.
+     */
+    localChangesCacheKey?: string;
+    /**
+     * Callback when local changes are cleared.
+     */
+    onClearLocalChanges?: () => void;
 };
 
 export type OnUpdateParams = {

package/src/types/fields.tsx

@@ -213,7 +213,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
 
     savingError?: Error;
 
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
 
     /**
      * This is the underlying formex controller that powers the form.
@@ -223,6 +223,12 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     formex: FormexController<M>;
 
     disabled: boolean;
+
+    /**
+     * Whether the form context is in read-only detail view mode.
+     * Custom entity views can use this to adjust their rendering.
+     */
+    readOnly?: boolean;
 }
 
 /**

package/src/util/dataControllerAdapter.ts

@@ -0,0 +1,93 @@
+/**
+ * Adapts an `EntityTableController<M>` (from @rebasepro/types) to a
+ * `CollectionDataController<T>` (from @rebasepro/ui), bridging the
+ * entity-aware data layer to the headless collection view.
+ */
+
+import { useMemo } from "react";
+import type { Entity, EntityTableController } from "@rebasepro/types";
+import type { CollectionDataController } from "@rebasepro/ui";
+
+/**
+ * Flatten Entity<M> objects to plain row objects.
+ * The headless view works with flat `Record<string, unknown>` rows,
+ * while the entity system uses `{ id, path, values: M }`.
+ *
+ * The flattened row includes `id` and `path` at the top level,
+ * plus all values spread.
+ */
+function flattenEntities<M extends Record<string, unknown>>(
+    entities: Entity<M>[]
+): Array<M & { id: string | number; path: string }> {
+    return entities.map(entity => ({
+        id: entity.id,
+        path: entity.path,
+        ...entity.values
+    }));
+}
+
+/**
+ * React hook that adapts an EntityTableController to a CollectionDataController.
+ *
+ * Usage:
+ * ```tsx
+ * const tableController = useDataTableController({ path, collection });
+ * const dataController = useCollectionDataController(tableController);
+ *
+ * <CollectionView dataController={dataController} ... />
+ * ```
+ */
+export function useCollectionDataController<M extends Record<string, unknown>>(
+    tableController: EntityTableController<M>
+): CollectionDataController<M & { id: string | number; path: string }> {
+    const flatData = useMemo(
+        () => flattenEntities(tableController.data),
+        [tableController.data]
+    );
+
+    return useMemo((): CollectionDataController<M & { id: string | number; path: string }> => ({
+        data: flatData,
+        loading: tableController.dataLoading,
+        noMoreToLoad: tableController.noMoreToLoad,
+        error: tableController.dataLoadingError,
+
+        filterValues: tableController.filterValues as Record<string, [string, unknown]> | undefined,
+        setFilterValues: tableController.setFilterValues as
+            ((values: Record<string, [string, unknown]> | undefined) => void) | undefined,
+
+        sortBy: tableController.sortBy,
+        setSortBy: tableController.setSortBy,
+
+        searchString: tableController.searchString,
+        setSearchString: tableController.setSearchString,
+
+        clearFilter: tableController.clearFilter,
+
+        initialScroll: tableController.initialScroll,
+        onScroll: tableController.onScroll,
+
+        paginationEnabled: tableController.paginationEnabled,
+        pageSize: tableController.pageSize,
+        itemCount: tableController.itemCount,
+        setItemCount: tableController.setItemCount,
+    }), [flatData, tableController]);
+}
+
+/**
+ * Non-hook version for cases where you already have the data
+ * and just need to build a static controller.
+ */
+export function createStaticDataController<T extends Record<string, unknown>>(
+    data: T[],
+    options?: {
+        loading?: boolean;
+        error?: Error;
+    }
+): CollectionDataController<T> {
+    return {
+        data,
+        loading: options?.loading ?? false,
+        noMoreToLoad: true,
+        error: options?.error,
+    };
+}

package/src/util/navigation_utils.ts

@@ -31,7 +31,7 @@ export function navigateToEntity({
 }:
 
     {
-        openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+        openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
         collection?: EntityCollection;
         entityId?: string | number;
         selectedTab?: string;

package/src/util/propertyConfigMapper.ts

@@ -0,0 +1,134 @@
+/**
+ * Maps a Rebase `Property` (from @rebasepro/types) to a `CollectionPropertyConfig`
+ * (from @rebasepro/ui), stripping all entity-specific fields and keeping only
+ * the UI-relevant subset.
+ *
+ * This is the bridge between the entity-aware and headless layers.
+ */
+
+import type { Property, Properties, EnumValues, EnumValueConfig } from "@rebasepro/types";
+import type { CollectionPropertyConfig, CollectionEnumValueConfig } from "@rebasepro/ui";
+
+/**
+ * Map Rebase property types to headless-supported types.
+ * `vector` and `binary` are not directly renderable, so we fall back to `string`.
+ */
+const TYPE_MAP: Record<string, CollectionPropertyConfig["type"]> = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    date: "date",
+    geopoint: "geopoint",
+    reference: "reference",
+    relation: "relation",
+    array: "array",
+    map: "map",
+    vector: "string",   // vectors display as text
+    binary: "string",   // binary displays as text
+};
+
+/**
+ * Convert a single Property to a CollectionPropertyConfig.
+ */
+export function mapPropertyToConfig(property: Property): CollectionPropertyConfig {
+    const base: CollectionPropertyConfig = {
+        type: TYPE_MAP[property.type] ?? "string",
+        name: property.name,
+        description: property.description,
+        columnWidth: property.ui?.columnWidth,
+        hideFromCollection: property.ui?.hideFromCollection,
+    };
+
+    // String-specific
+    if (property.type === "string") {
+        if (property.enum) {
+            base.enum = mapEnumValues(property.enum);
+        }
+        if (property.multiline) base.multiline = true;
+        if (property.ui?.previewAsTag) base.previewAsTag = true;
+        if (property.url || property.ui?.url) base.url = property.url ?? property.ui?.url;
+        if (property.ui?.markdown || property.markdown) base.markdown = true;
+        if (property.storage) base.storage = true;
+        if (property.email) base.email = true;
+    }
+
+    // Number-specific
+    if (property.type === "number" && property.enum) {
+        base.enum = mapEnumValues(property.enum);
+    }
+
+    // Array-specific
+    if (property.type === "array" && property.of && !Array.isArray(property.of)) {
+        base.of = mapPropertyToConfig(property.of);
+    }
+
+    // Map-specific
+    if (property.type === "map" && property.properties) {
+        base.properties = mapPropertiesToConfigs(property.properties);
+        if (property.propertiesOrder) {
+            base.propertiesOrder = property.propertiesOrder;
+        }
+    }
+
+    // Date-specific
+    if (property.type === "date" && property.mode) {
+        base.mode = property.mode;
+    }
+
+    // Custom preview component
+    if (property.ui?.Preview) {
+        // The connected wrapper will handle this by injecting via cellRenderer override
+        // We don't copy it here because Preview may reference entity-aware components
+    }
+
+    return base;
+}
+
+/**
+ * Convert a Properties record to a CollectionPropertyConfig record.
+ */
+export function mapPropertiesToConfigs(
+    properties: Properties
+): Record<string, CollectionPropertyConfig> {
+    const result: Record<string, CollectionPropertyConfig> = {};
+    for (const [key, property] of Object.entries(properties)) {
+        result[key] = mapPropertyToConfig(property);
+    }
+    return result;
+}
+
+/**
+ * Convert Rebase EnumValues to CollectionEnumValueConfig format.
+ * Handles both array form (EnumValueConfig[]) and record form.
+ */
+function mapEnumValues(
+    enumValues: EnumValues | undefined
+): Record<string, CollectionEnumValueConfig> | Map<string | number, CollectionEnumValueConfig> | undefined {
+    if (!enumValues) return undefined;
+
+    // Array form: EnumValueConfig[]
+    if (Array.isArray(enumValues)) {
+        const result: Record<string, CollectionEnumValueConfig> = {};
+        for (const item of enumValues) {
+            result[String(item.id)] = normalizeEnumValueConfig(item);
+        }
+        return result;
+    }
+
+    // Record form: Record<string | number, string | EnumValueConfig>
+    const result: Record<string, CollectionEnumValueConfig> = {};
+    for (const [key, value] of Object.entries(enumValues)) {
+        result[key] = typeof value === "string"
+            ? value
+            : normalizeEnumValueConfig(value);
+    }
+    return result;
+}
+
+function normalizeEnumValueConfig(config: EnumValueConfig): CollectionEnumValueConfig {
+    return {
+        label: config.label,
+        color: typeof config.color === "string" ? config.color : undefined,
+        disabled: config.disabled,
+    };
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Rebase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.