@contember/bindx-react 0.1.45 → 0.1.47

package/src/hooks/useEntity.ts

@@ -323,9 +323,13 @@ export function useEntity(
 	}, [entityType, id, byKey, effectiveQueryKey, options.cache, batcher, store, dispatcher, selectionMeta])
 
 	// --- EntityHandle ---
+	// The handle keeps a stable identity across data changes — it is a stateless live view over the
+	// store (see BaseHandle), so `snapshot` is intentionally NOT a dependency here. The host already
+	// re-renders on data changes via useStoreSubscription above (keeping inline `accessor.value`
+	// reads fresh), and memoized children re-render through their own subscription (useField/useAccessor).
 	const rawHandle = useMemo(
 		() => EntityHandle.createRaw(id, entityType, store, dispatcher, schemaRegistry as SchemaRegistry<Record<string, object>>, undefined, selectionMeta),
-		[id, entityType, store, dispatcher, schemaRegistry, snapshot, selectionMeta],
+		[id, entityType, store, dispatcher, schemaRegistry, selectionMeta],
 	)
 
 	const handle = useMemo(
@@ -333,11 +337,6 @@ export function useEntity(
 		[rawHandle],
 	)
 
-	// `snapshot` is a useMemo dep, so `rawHandle` is recreated on every entity data change (to give
-	// memoized children a fresh reference). Superseded handles need no cleanup: EntityHandle is a
-	// stateless live view that owns no resources (see BaseHandle), so it is reclaimed by GC once
-	// unreferenced and a handle a consumer still holds stays usable for late reads/writes.
-
 	// --- Persist & reset callbacks ---
 	const persist = useCallback(async () => {
 		await batchPersister.persist(entityType, id)
@@ -347,6 +346,33 @@ export function useEntity(
 		rawHandle.reset()
 	}, [rawHandle])
 
+	// Keep the public ready proxy stable while serving fresh metadata from each render.
+	const readyMetaRef = useRef<ReadyResultMeta>({
+		$status: 'ready',
+		$isLoading: false,
+		$isRefetching: false,
+		$isError: false,
+		$isNotFound: false,
+		$error: null,
+		$persist: persist,
+		$reset: reset,
+	})
+	readyMetaRef.current = {
+		$status: 'ready',
+		$isLoading: false,
+		$isRefetching: isRefetching,
+		$isError: false,
+		$isNotFound: false,
+		$error: null,
+		$persist: persist,
+		$reset: reset,
+	}
+
+	const readyResult = useMemo(
+		() => createReadyResult(handle, readyMetaRef),
+		[handle],
+	)
+
 	// --- Build result ---
 	const result = useMemo((): UseEntityResult<object, object> => {
 		if (!loadState || loadState.status === 'loading' || (!snapshot && loadState.status === 'success')) {
@@ -362,8 +388,8 @@ export function useEntity(
 		}
 
 		// Ready — layer status metadata on top of EntityHandle proxy
-		return createReadyResult(handle, persist, reset, isRefetching)
-	}, [snapshot, loadState, isPersisting, id, handle, persist, reset, isRefetching])
+		return readyResult
+	}, [snapshot, loadState, isPersisting, id, persist, reset, readyResult])
 
 	// Proxy-based result satisfies the full UseEntityResult<T> at runtime via field access delegation
 	return result as UseEntityResult<any, any>
@@ -373,32 +399,32 @@ export function useEntity(
 // Result factories
 // ============================================================================
 
+interface ReadyResultMeta extends Record<string, unknown> {
+	readonly $status: 'ready'
+	readonly $isLoading: false
+	readonly $isRefetching: boolean
+	readonly $isError: false
+	readonly $isNotFound: false
+	readonly $error: null
+	$persist(): Promise<void>
+	$reset(): void
+}
+
 function createReadyResult(
 	handle: EntityAccessor<object, object>,
-	persist: () => Promise<void>,
-	reset: () => void,
-	isRefetching: boolean,
+	metaRef: { readonly current: ReadyResultMeta },
 ): UseEntityResult<object, object> {
-	const meta: Record<string, unknown> = {
-		$status: 'ready' as const,
-		$isLoading: false as const,
-		$isRefetching: isRefetching,
-		$isError: false as const,
-		$isNotFound: false as const,
-		$error: null,
-		$persist: persist,
-		$reset: reset,
-	}
-
 	// Proxy merges status metadata onto EntityAccessor — satisfies ReadyEntityResult at runtime
 	return new Proxy(handle as object, {
 		get(target, prop, receiver) {
+			const meta = metaRef.current
 			if (typeof prop === 'string' && prop in meta) {
 				return meta[prop]
 			}
 			return Reflect.get(target, prop, receiver)
 		},
 		has(target, prop) {
+			const meta = metaRef.current
 			if (typeof prop === 'string' && prop in meta) {
 				return true
 			}

package/src/hooks/useEntityCount.ts

@@ -38,7 +38,6 @@ export interface UseEntityCountResult {
  * recompute the count. Batched into the same request as any sibling list query.
  */
 export function useEntityCount(
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	entity: EntityDef<any>,
 	options: UseEntityCountOptions = {},
 ): UseEntityCountResult {

package/src/hooks/useEntityList.ts

@@ -3,6 +3,7 @@ import type { EntityDef, EntityAccessor, SelectionInput, SelectionMeta, FieldErr
 import { EntityHandle, isTempId, resolveSelectionMeta, buildQueryFromSelection, refreshServerData, createLoadError } from '@contember/bindx'
 import { useBindxContext, useSchemaRegistry } from './BackendAdapterContext.js'
 import { useStoreSubscription } from './useStoreSubscription.js'
+import { ItemAccessorCache } from './ItemAccessorCache.js'
 
 // ============================================================================
 // Options
@@ -162,11 +163,9 @@ export function useEntityList(
 // Implementation
 // ============================================================================
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function useEntityList(
 	entity: EntityDef<any>,
 	options: UseEntityListOptions,
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	definer?: SelectionInput<any, any>,
 ): UseEntityListResult<any> {
 	const schemaRegistry = useSchemaRegistry()
@@ -231,9 +230,38 @@ export function useEntityList(
 		storeVersion: number
 		status: string
 		isRefetching: boolean
+		accessorCache: ItemAccessorCache
 		result: UseEntityListResult<any>
 	} | null>(null)
 
+	// --- Item accessor cache ---
+	// Kept for the hook's lifetime so item identity survives a list snapshot rebuild. Dropped
+	// whenever a handle construction input changes — handles are built against `selectionMeta` and
+	// validate field access against it. A new cache also invalidates `listCacheRef`, so a widened
+	// selection never serves the previous result with its narrow accessors.
+	// Canonical id of a list item: a temp id follows its temp→persisted rekey. The list
+	// state keeps the id it was given, so every id comparison goes through this.
+	const resolveItemId = useCallback(
+		(id: string): string => store.resolveEntityId(entityType, id),
+		[store, entityType],
+	)
+
+	const itemAccessorCache = useMemo(
+		() => new ItemAccessorCache(
+			(id) => EntityHandle.createRaw<object>(
+				id,
+				entityType,
+				store,
+				dispatcher,
+				schemaRegistry as SchemaRegistry<Record<string, object>>,
+				undefined,
+				selectionMeta,
+			),
+			resolveItemId,
+		),
+		[entityType, store, dispatcher, schemaRegistry, selectionMeta, resolveItemId],
+	)
+
 	// --- Store subscription ---
 	const subscribe = useCallback(
 		(onStoreChange: () => void) => {
@@ -266,11 +294,12 @@ export function useEntityList(
 			} else {
 				store.scheduleForDeletion(entityType, key)
 			}
-			listStateRef.current.items = listStateRef.current.items.filter(item => item.id !== key)
+			const removedId = resolveItemId(key)
+			listStateRef.current.items = listStateRef.current.items.filter(item => resolveItemId(item.id) !== removedId)
 			versionRef.current++
 			store.notify()
 		},
-		[entityType, store],
+		[entityType, store, resolveItemId],
 	)
 
 	const moveItem = useCallback(
@@ -322,7 +351,8 @@ export function useEntityList(
 			cache.version === version &&
 			cache.storeVersion === storeVersion &&
 			cache.status === state.status &&
-			cache.isRefetching === state.isRefetching
+			cache.isRefetching === state.isRefetching &&
+			cache.accessorCache === itemAccessorCache
 		) {
 			return cache.result
 		}
@@ -334,17 +364,14 @@ export function useEntityList(
 		} else if (state.status === 'error') {
 			result = createErrorListResult(state.error!)
 		} else {
-			const items = state.items.map((item) => {
-				return EntityHandle.create<object>(
-					item.id,
-					entityType,
-					store,
-					dispatcher,
-					schemaRegistry as SchemaRegistry<Record<string, object>>,
-					undefined,
-					selectionMeta,
-				) as unknown as EntityAccessor<any>
+			state.items = state.items.map(item => {
+				const id = resolveItemId(item.id)
+				return id === item.id ? item : { id, data: item.data }
 			})
+			// The array itself is deliberately NOT identity-stable: consumers that only re-render
+			// through a parent (the DataGrid render chain) rely on a fresh array per store bump.
+			// Per-item accessor identity is the stable part — see ItemAccessorCache.
+			const items = itemAccessorCache.build(state.items)
 
 			result = {
 				$status: 'ready',
@@ -366,11 +393,12 @@ export function useEntityList(
 			storeVersion,
 			status: state.status,
 			isRefetching: state.isRefetching,
+			accessorCache: itemAccessorCache,
 			result,
 		}
 
 		return result
-	}, [entityType, store, dispatcher, schemaRegistry, selectionMeta, addItem, removeItem, moveItem])
+	}, [store, itemAccessorCache, addItem, removeItem, moveItem, resolveItemId])
 
 	const isEqual = useCallback(
 		(a: UseEntityListResult<any>, b: UseEntityListResult<any>): boolean => {

package/src/hooks/useFields.ts

@@ -0,0 +1,118 @@
+import { useCallback, useRef, useSyncExternalStore } from 'react'
+import {
+	FIELD_REF_META,
+	type FieldAccessor,
+	type FieldRef,
+	type FieldRefMeta,
+} from '@contember/bindx'
+import { useSnapshotStore } from './BackendAdapterContext.js'
+
+/** Entity to watch, derived from a ref's field metadata. */
+interface SubscriptionTarget {
+	readonly entityType: string
+	readonly entityId: string
+}
+
+function hasFieldRefMeta(value: unknown): value is { readonly [FIELD_REF_META]: FieldRefMeta } {
+	return typeof value === 'object' && value !== null && FIELD_REF_META in value
+}
+
+/** Deduplicates the entities behind `refs`; entries without field metadata are ignored. */
+function collectTargets(refs: ReadonlyArray<unknown>): SubscriptionTarget[] {
+	const targets: SubscriptionTarget[] = []
+	const seen = new Map<string, Set<string>>()
+
+	for (const ref of refs) {
+		if (!hasFieldRefMeta(ref)) continue
+		const meta = ref[FIELD_REF_META]
+		if (!meta) continue
+		let ids = seen.get(meta.entityType)
+		if (!ids) {
+			ids = new Set()
+			seen.set(meta.entityType, ids)
+		}
+		if (ids.has(meta.entityId)) continue
+		ids.add(meta.entityId)
+		targets.push({ entityType: meta.entityType, entityId: meta.entityId })
+	}
+
+	targets.sort((left, right) => {
+		if (left.entityType < right.entityType) return -1
+		if (left.entityType > right.entityType) return 1
+		if (left.entityId < right.entityId) return -1
+		if (left.entityId > right.entityId) return 1
+		return 0
+	})
+	return targets
+}
+
+type FieldAccessorFor<TRef> = TRef extends FieldRef<infer TValue>
+	? FieldAccessor<TValue>
+	: TRef extends null
+		? null
+		: never
+
+type FieldRefFor<TRef> = TRef extends FieldRef<infer TValue>
+	? FieldRef<TValue>
+	: TRef extends null
+		? null
+		: never
+
+type FieldAccessorTuple<TRefs extends readonly unknown[]> = {
+	readonly [TIndex in keyof TRefs]: FieldAccessorFor<TRefs[TIndex]>
+}
+
+type FieldRefTuple<TRefs extends readonly unknown[]> = {
+	readonly [TIndex in keyof TRefs]: FieldRefFor<TRefs[TIndex]>
+}
+
+/** Internal subscription path for metadata-bearing refs of any kind. */
+export function useRefSubscription(refs: readonly unknown[]): readonly unknown[] {
+	const store = useSnapshotStore()
+	const targets = collectTargets(refs)
+	const subscriptionKey = JSON.stringify(targets)
+	const stableTargetsRef = useRef({ subscriptionKey, targets })
+	if (stableTargetsRef.current.subscriptionKey !== subscriptionKey) {
+		stableTargetsRef.current = { subscriptionKey, targets }
+	}
+	const stableTargets = stableTargetsRef.current.targets
+	const hasTargets = stableTargets.length > 0
+
+	const subscribe = useCallback(
+		(callback: () => void): (() => void) => {
+			const unsubscribes = stableTargets.map(target =>
+				store.subscribeToEntity(target.entityType, target.entityId, callback),
+			)
+			return () => {
+				for (const unsubscribe of unsubscribes) unsubscribe()
+			}
+		},
+		[store, stableTargets],
+	)
+
+	const getSnapshot = useCallback(
+		(): number => (hasTargets ? store.getVersion() : 0),
+		[store, hasTargets],
+	)
+
+	useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
+	return refs
+}
+
+/**
+ * Subscribes to every entity behind `refs` with a single hook, so the hook count stays
+ * constant no matter how many refs are passed. Use it wherever the number of refs is
+ * driven by data or by children (`<Switch>` cases, condition DSL fields) — calling
+ * {@link useField} in a loop breaks the rules of hooks the moment the count changes.
+ *
+ * @example
+ * ```tsx
+ * const accessors = useFields([article.title, article.publishedAt])
+ * ```
+ */
+export function useFields<const TRefs extends readonly unknown[]>(
+	refs: TRefs & FieldRefTuple<TRefs>,
+): FieldAccessorTuple<TRefs>
+export function useFields(refs: ReadonlyArray<unknown>): unknown {
+	return useRefSubscription(refs)
+}

package/src/index.ts

@@ -99,7 +99,6 @@ export type {
 	// Undo types
 	UndoManagerConfig,
 	UndoState,
-	UndoEntry,
 	// Event types
 	BindxEvent,
 	FieldScopedEvent,
@@ -310,6 +309,7 @@ export {
 	// Ref → Accessor hooks
 	useAccessor,
 	useField,
+	useFields,
 	useHasMany,
 	useHasOne,
 	// Notifications

package/src/jsx/analyzer.ts

@@ -60,8 +60,15 @@ export function analyzeJsx(node: ReactNode, selection: SelectionMetaCollector):
 			return nestedSelection
 		}
 
-		// Get selection info from the component
-		const fieldSelection = provider.getSelection(element.props, collectNested)
+		// Get selection info from the component. A throw here must not silently
+		// drop the sibling components' selections — report it and continue.
+		let fieldSelection: ReturnType<SelectionProvider['getSelection']>
+		try {
+			fieldSelection = provider.getSelection(element.props, collectNested)
+		} catch (error) {
+			reportAnalysisError(component, error)
+			return
+		}
 
 		// Add to selection
 		if (fieldSelection) {
@@ -85,11 +92,15 @@ export function analyzeJsx(node: ReactNode, selection: SelectionMetaCollector):
 		'staticRender' in component &&
 		typeof (component as { staticRender: unknown }).staticRender === 'function'
 	) {
-		const staticJsx = (component as { staticRender: (props: Record<string, unknown>) => ReactNode }).staticRender(
-			element.props as Record<string, unknown>,
-		)
-		if (staticJsx) {
-			analyzeJsx(staticJsx, selection)
+		try {
+			const staticJsx = (component as { staticRender: (props: Record<string, unknown>) => ReactNode }).staticRender(
+				element.props as Record<string, unknown>,
+			)
+			if (staticJsx) {
+				analyzeJsx(staticJsx, selection)
+			}
+		} catch (error) {
+			reportAnalysisError(component, error)
 		}
 		return
 	}
@@ -102,6 +113,20 @@ export function analyzeJsx(node: ReactNode, selection: SelectionMetaCollector):
 	}
 }
 
+/**
+ * Reports a selection-analysis failure of a single component with attribution,
+ * so one broken component doesn't silently cost its siblings their selection.
+ */
+function reportAnalysisError(component: unknown, error: unknown): void {
+	const c = component as { displayName?: string; name?: string; type?: { displayName?: string; name?: string } }
+	const name = c.displayName ?? c.type?.displayName ?? (c.name || c.type?.name) ?? 'anonymous'
+	console.error(
+		`[bindx] Selection analysis of <${name}> failed — its fields were NOT added to the fetch plan. `
+		+ 'Fix the error below; fields it uses may be missing from queries until then.',
+		error,
+	)
+}
+
 /**
  * Collects all field selections from a JSX tree.
  * Entry point for the collection phase.

package/src/jsx/componentBuilder.ts

@@ -49,6 +49,7 @@ export class ComponentBuilderImpl<
 		private readonly hasInterfacesMode: boolean = false,
 		private readonly conditionFn: ((props: Record<string, unknown>) => Condition) | null = null,
 		private readonly slotNames: readonly string[] = ['children'],
+		private readonly useFns: readonly ((props: Record<string, unknown>) => object)[] = [],
 	) {}
 
 	entity(
@@ -67,6 +68,7 @@ export class ComponentBuilderImpl<
 			this.hasInterfacesMode,
 			this.conditionFn,
 			this.slotNames,
+			this.useFns,
 		)
 	}
 
@@ -96,6 +98,7 @@ export class ComponentBuilderImpl<
 			true, // Enable interfaces mode for discovery of implicit interface props
 			this.conditionFn,
 			this.slotNames,
+			this.useFns,
 		)
 	}
 
@@ -108,6 +111,19 @@ export class ComponentBuilderImpl<
 			this.hasInterfacesMode,
 			this.conditionFn,
 			this.slotNames,
+			this.useFns,
+		)
+	}
+
+	use(useFn: (props: Record<string, unknown>) => object): ComponentBuilderImpl<TState> {
+		return new ComponentBuilderImpl(
+			this.schemaRegistry,
+			this.entityConfigs,
+			this.roles,
+			this.hasInterfacesMode,
+			this.conditionFn,
+			this.slotNames,
+			[...this.useFns, useFn],
 		)
 	}
 
@@ -119,6 +135,7 @@ export class ComponentBuilderImpl<
 			this.hasInterfacesMode,
 			conditionFn,
 			this.slotNames,
+			this.useFns,
 		)
 	}
 
@@ -130,6 +147,7 @@ export class ComponentBuilderImpl<
 			this.hasInterfacesMode,
 			this.conditionFn,
 			names,
+			this.useFns,
 		)
 	}
 
@@ -142,6 +160,7 @@ export class ComponentBuilderImpl<
 			this.schemaRegistry,
 			this.conditionFn,
 			this.slotNames,
+			this.useFns,
 		)
 	}
 }
@@ -159,13 +178,11 @@ export class ComponentBuilderImpl<
 export function createComponentBuilder(
 	schemaRegistry: SchemaRegistry<Record<string, object>> | null,
 	roles: readonly string[] = [],
-// eslint-disable-next-line @typescript-eslint/ban-types
 ): ComponentBuilder<ComponentBuilderState<{}, object, typeof roles>> {
 	return new ComponentBuilderImpl(
 		schemaRegistry,
 		new Map(),
 		roles,
-	// eslint-disable-next-line @typescript-eslint/ban-types
 	) as unknown as ComponentBuilder<ComponentBuilderState<{}, object, typeof roles>>
 }
 

package/src/jsx/componentBuilder.types.ts

@@ -103,14 +103,15 @@ export type AnyEntityPropConfig = EntityPropConfig | InterfaceEntityPropConfig
  * Grows as you chain builder methods.
  */
 export interface ComponentBuilderState<
-	// eslint-disable-next-line @typescript-eslint/ban-types
 	TEntityProps extends Record<string, AnyEntityPropConfig> = {},
 	TScalarProps extends object = object,
 	TRoles extends readonly string[] = readonly string[],
+	TUseProps extends object = {},
 > {
 	readonly __entityProps: TEntityProps
 	readonly __scalarProps: TScalarProps
 	readonly __roles: TRoles
+	readonly __useProps: TUseProps
 }
 
 // ============================================================================
@@ -130,7 +131,8 @@ export type AddImplicitEntity<
 		readonly [K in TPropName]: ImplicitEntityConfig<TEntity>
 	},
 	TState['__scalarProps'],
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
 >
 
 /**
@@ -147,7 +149,8 @@ export type AddExplicitEntity<
 		readonly [K in TPropName]: ExplicitEntityConfig<TEntity, TSelected>
 	},
 	TState['__scalarProps'],
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
 >
 
 /**
@@ -162,7 +165,8 @@ export type AddImplicitInterfaceEntity<
 		readonly [K in TPropName]: ImplicitInterfaceEntityConfig<TInterface>
 	},
 	TState['__scalarProps'],
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
 >
 
 /**
@@ -177,7 +181,8 @@ export type AddExplicitInterfaceEntity<
 		readonly [K in TPropName]: ExplicitInterfaceEntityConfig<TInterface>
 	},
 	TState['__scalarProps'],
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
 >
 
 /**
@@ -192,7 +197,8 @@ export type AddInterfaces<
 		readonly [K in keyof TInterfaces]: InterfaceEntityPropConfig<TInterfaces[K]>
 	},
 	TState['__scalarProps'],
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
 >
 
 /**
@@ -214,7 +220,21 @@ export type SetScalarProps<
 > = ComponentBuilderState<
 	TState['__entityProps'],
 	TNewScalarProps,
-	TState['__roles']
+	TState['__roles'],
+	TState['__useProps']
+>
+
+/**
+ * Merge runtime-only values from .use() into builder state.
+ */
+export type AddUseProps<
+	TState extends ComponentBuilderState,
+	TUse extends object,
+> = ComponentBuilderState<
+	TState['__entityProps'],
+	TState['__scalarProps'],
+	TState['__roles'],
+	TState['__useProps'] & TUse
 >
 
 // ============================================================================
@@ -273,9 +293,12 @@ export type BuildProps<TState extends ComponentBuilderState> =
 
 /**
  * Build complete render props type from builder state.
+ * Includes .use() values — they exist only inside the render function,
+ * never on the public props (BuildProps).
  */
 export type BuildRenderProps<TState extends ComponentBuilderState> =
 	TState['__scalarProps'] &
+		TState['__useProps'] &
 		BuildRenderEntityProps<TState['__entityProps'], TState['__roles']>
 
 /**
@@ -425,6 +448,38 @@ export interface ComponentBuilder<
 	 */
 	props<TNewScalarProps extends object>(): ComponentBuilder<SetScalarProps<TState, TNewScalarProps>>
 
+	/**
+	 * Provide runtime-only values to the render function — hooks are allowed here.
+	 *
+	 * The function runs during every React render (inside the component), so
+	 * `useT()`, `useContext()`, `useMemo()` etc. all work. It is NEVER executed
+	 * during static selection analysis — its outputs are replaced by inert
+	 * stand-ins there, so the render body can use them freely without crashing
+	 * the collection pass.
+	 *
+	 * This removes the need for thin wrapper components that only thread
+	 * hook-derived values in as props (which also break selection discovery,
+	 * because the JSX walk cannot see through plain components).
+	 *
+	 * Can be chained; later use() functions see the values of earlier ones.
+	 *
+	 * @example
+	 * ```typescript
+	 * createComponent()
+	 *   .entity('article', schema.Article)
+	 *   .use(() => ({ t: useTranslator() }))
+	 *   .render(({ article, t }) => (
+	 *     <div>
+	 *       <h2>{t('article.heading')}</h2>
+	 *       <Field field={article.title} />
+	 *     </div>
+	 *   ))
+	 * ```
+	 */
+	use<TUse extends object>(
+		useFn: (props: BuildRenderProps<TState>) => TUse,
+	): ComponentBuilder<AddUseProps<TState, TUse>>
+
 	/**
 	 * Add a condition that must be true for the component to render.
 	 * If the condition is false, the component renders null.
@@ -492,7 +547,6 @@ export interface ComponentBuilder<
  */
 export type InitialBuilderState<
 	TRoles extends readonly string[] = readonly string[],
-	// eslint-disable-next-line @typescript-eslint/ban-types
 > = ComponentBuilderState<{}, object, TRoles>
 
 /**

package/src/jsx/componentBuilderCompat.ts

@@ -13,7 +13,6 @@ import { BINDX_COMPONENT } from './types.js'
  * @internal
  */
 export function assignFragmentProperties(
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	component: ComponentType<any>,
 	selectionsMap: Map<string, SelectionPropMeta>,
 ): void {
@@ -28,7 +27,6 @@ export function assignFragmentProperties(
  * @internal
  */
 export function assignComponentMarkers(
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	component: ComponentType<any>,
 	selectionsMap: Map<string, SelectionPropMeta>,
 ): void {