@contember/react-board 2.1.0-alpha.30 → 2.1.0-alpha.35

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contember/react-board",
   "license": "Apache-2.0",
-  "version": "2.1.0-alpha.30",
+  "version": "2.1.0-alpha.35",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/production/index.js",
@@ -30,20 +30,20 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/contember/interface.git",
+    "url": "git+https://github.com/contember/contember.git",
     "directory": "packages/react-board"
   },
   "dependencies": {
-    "@contember/react-binding": "2.1.0-alpha.30",
-    "@contember/react-multipass-rendering": "2.1.0-alpha.30",
-    "@contember/react-utils": "2.1.0-alpha.30"
+    "@contember/react-binding": "workspace:*",
+    "@contember/react-multipass-rendering": "workspace:*",
+    "@contember/react-utils": "workspace:*"
   },
   "peerDependencies": {
-    "react": "^18 || ^19",
-    "react-dom": "^18 || ^19"
+    "react": "catalog:",
+    "react-dom": "catalog:"
   },
   "devDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
+    "react": "catalog:",
+    "react-dom": "catalog:"
   }
 }

package/src/components/Board.tsx

@@ -23,7 +23,6 @@ export type BoardProps =
 	| BoardQualifiedStaticProps
 	| BoardRelativeStaticProps
 
-
 export const Board = Component<BoardProps>(props => {
 	if ('entities' in props) {
 		if (Array.isArray(props.columns)) {
@@ -54,170 +53,180 @@ export type BoardStaticColumnsBindingProps = {
 	discriminationField: string | SugaredRelativeSingleField
 }
 
-export type BoardCommonProps =
-	& {
-		children: ReactNode
-		sortableBy?: string | SugaredRelativeSingleField
-		sortScope?: 'column' | 'board'
-	}
-
-export type BoardQualifiedItemsProps =
-	& Pick<SugaredQualifiedEntityList, 'entities' | 'orderBy' | 'limit' | 'offset'>
-
+export type BoardCommonProps = {
+	children: ReactNode
+	sortableBy?: string | SugaredRelativeSingleField
+	sortScope?: 'column' | 'board'
+}
 
-export type BoardRelativeItemsProps =
-	& Pick<SugaredRelativeEntityList, 'field' | 'orderBy' | 'limit' | 'offset'>
+export type BoardQualifiedItemsProps = Pick<SugaredQualifiedEntityList, 'entities' | 'orderBy' | 'limit' | 'offset'>
 
+export type BoardRelativeItemsProps = Pick<SugaredRelativeEntityList, 'field' | 'orderBy' | 'limit' | 'offset'>
 
 export type BoardQualifiedDynamicProps =
 	& BoardCommonProps
 	& BoardDynamicColumnsBindingProps
 	& BoardQualifiedItemsProps
 
-const BoardQualifiedDynamic = Component<BoardQualifiedDynamicProps>(({ entities, orderBy, limit, offset, columns, columnsSortableBy, discriminationField, sortableBy, sortScope, children }) => {
-	const itemsAccessor = useEntityListSubTree({ entities, orderBy, limit, offset })
-	const columnsAccessor = useEntityListSubTree({ entities: columns })
-	const [data, methods] = useDynamicBoard({
-		columnEntities: columnsAccessor,
-		itemEntities: itemsAccessor,
-		columns,
-		sortableBy,
-		sortScope,
-		columnsSortableBy,
-		discriminationField,
-	})
-	return (
-		<BoardMethodsContext.Provider value={methods}>
-			<BoardColumnsContext.Provider value={data.columns}>
-				{children}
-			</BoardColumnsContext.Provider>
-		</BoardMethodsContext.Provider>
-	)
-}, ({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, columnsSortableBy, children }, env) => {
-
-	const childrenByType = boardAnalyzer.processChildren(children, env)
-	const columnChildren = childrenByType.filter(it => it.type === 'column').map(it => it.children)
-	const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
-
-	return (<>
-		<EntityListSubTree entities={entities} orderBy={orderBy} limit={limit} offset={offset}>
-			<HasOne {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
-			{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
-			{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</EntityListSubTree>
-		<EntityListSubTree entities={columns}>
-			{columnsSortableBy && <Field {...typeof columnsSortableBy === 'string' ? { field: columnsSortableBy } : columnsSortableBy} />}
-			{columnChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</EntityListSubTree>
-	</>)
-})
-
+const BoardQualifiedDynamic = Component<BoardQualifiedDynamicProps>(
+	({ entities, orderBy, limit, offset, columns, columnsSortableBy, discriminationField, sortableBy, sortScope, children }) => {
+		const itemsAccessor = useEntityListSubTree({ entities, orderBy, limit, offset })
+		const columnsAccessor = useEntityListSubTree({ entities: columns })
+		const [data, methods] = useDynamicBoard({
+			columnEntities: columnsAccessor,
+			itemEntities: itemsAccessor,
+			columns,
+			sortableBy,
+			sortScope,
+			columnsSortableBy,
+			discriminationField,
+		})
+		return (
+			<BoardMethodsContext.Provider value={methods}>
+				<BoardColumnsContext.Provider value={data.columns}>
+					{children}
+				</BoardColumnsContext.Provider>
+			</BoardMethodsContext.Provider>
+		)
+	},
+	({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, columnsSortableBy, children }, env) => {
+		const childrenByType = boardAnalyzer.processChildren(children, env)
+		const columnChildren = childrenByType.filter(it => it.type === 'column').map(it => it.children)
+		const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
+
+		return (
+			<>
+				<EntityListSubTree entities={entities} orderBy={orderBy} limit={limit} offset={offset}>
+					<HasOne {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
+					{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
+					{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</EntityListSubTree>
+				<EntityListSubTree entities={columns}>
+					{columnsSortableBy && <Field {...typeof columnsSortableBy === 'string' ? { field: columnsSortableBy } : columnsSortableBy} />}
+					{columnChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</EntityListSubTree>
+			</>
+		)
+	},
+)
 
 export type BoardRelativeDynamicProps =
 	& BoardCommonProps
 	& BoardDynamicColumnsBindingProps
 	& BoardRelativeItemsProps
 
-
-const RelativeDynamicBoard = Component<BoardRelativeDynamicProps>(({ field, orderBy, limit, offset, columns, columnsSortableBy, discriminationField, sortableBy, sortScope, children }) => {
-	const itemsAccessor = useEntityList({ field, orderBy, limit, offset })
-	const columnsAccessor = useEntityListSubTree({ entities: columns })
-	const [data, methods] = useDynamicBoard({
-		columnEntities: columnsAccessor,
-		itemEntities: itemsAccessor,
-		columns,
-		sortableBy,
-		sortScope,
-		columnsSortableBy,
-		discriminationField,
-	})
-	return (
-		<BoardMethodsContext.Provider value={methods}>
-			<BoardColumnsContext.Provider value={data.columns}>
-				{children}
-			</BoardColumnsContext.Provider>
-		</BoardMethodsContext.Provider>
-	)
-}, ({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, columnsSortableBy, children }, env) => {
-	const childrenByType = boardAnalyzer.processChildren(children, env)
-	const columnChildren = childrenByType.filter(it => it.type === 'column').map(it => it.children)
-	const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
-	return (<>
-		<HasMany field={field} orderBy={orderBy} limit={limit} offset={offset}>
-			<HasOne {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
-			{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
-			{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</HasMany>
-		<EntityListSubTree entities={columns}>
-			{columnsSortableBy && <Field {...typeof columnsSortableBy === 'string' ? { field: columnsSortableBy } : columnsSortableBy} />}
-			{columnChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</EntityListSubTree>
-	</>)
-})
+const RelativeDynamicBoard = Component<BoardRelativeDynamicProps>(
+	({ field, orderBy, limit, offset, columns, columnsSortableBy, discriminationField, sortableBy, sortScope, children }) => {
+		const itemsAccessor = useEntityList({ field, orderBy, limit, offset })
+		const columnsAccessor = useEntityListSubTree({ entities: columns })
+		const [data, methods] = useDynamicBoard({
+			columnEntities: columnsAccessor,
+			itemEntities: itemsAccessor,
+			columns,
+			sortableBy,
+			sortScope,
+			columnsSortableBy,
+			discriminationField,
+		})
+		return (
+			<BoardMethodsContext.Provider value={methods}>
+				<BoardColumnsContext.Provider value={data.columns}>
+					{children}
+				</BoardColumnsContext.Provider>
+			</BoardMethodsContext.Provider>
+		)
+	},
+	({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, columnsSortableBy, children }, env) => {
+		const childrenByType = boardAnalyzer.processChildren(children, env)
+		const columnChildren = childrenByType.filter(it => it.type === 'column').map(it => it.children)
+		const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
+		return (
+			<>
+				<HasMany field={field} orderBy={orderBy} limit={limit} offset={offset}>
+					<HasOne {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
+					{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
+					{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</HasMany>
+				<EntityListSubTree entities={columns}>
+					{columnsSortableBy && <Field {...typeof columnsSortableBy === 'string' ? { field: columnsSortableBy } : columnsSortableBy} />}
+					{columnChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</EntityListSubTree>
+			</>
+		)
+	},
+)
 export type BoardQualifiedStaticProps =
 	& BoardCommonProps
 	& BoardStaticColumnsBindingProps
 	& BoardQualifiedItemsProps
 
-
-const BoardQualifiedStatic = Component<BoardQualifiedStaticProps>(({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, sortScope, children }) => {
-	const itemsAccessor = useEntityListSubTree({ entities, orderBy, limit, offset })
-	const [data, methods] = useStaticBoard({
-		itemEntities: itemsAccessor,
-		columns,
-		sortableBy,
-		sortScope,
-		discriminationField,
-	})
-	return (
-		<BoardMethodsContext.Provider value={methods}>
-			<BoardColumnsContext.Provider value={data.columns}>
-				{children}
-			</BoardColumnsContext.Provider>
-		</BoardMethodsContext.Provider>
-	)
-}, ({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, children }, env) => {
-	const childrenByType = boardAnalyzer.processChildren(children, env)
-	const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
-	return (<>
-		<EntityListSubTree entities={entities} orderBy={orderBy} limit={limit} offset={offset}>
-			<Field {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
-			{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
-			{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</EntityListSubTree>
-	</>)
-})
-
+const BoardQualifiedStatic = Component<BoardQualifiedStaticProps>(
+	({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, sortScope, children }) => {
+		const itemsAccessor = useEntityListSubTree({ entities, orderBy, limit, offset })
+		const [data, methods] = useStaticBoard({
+			itemEntities: itemsAccessor,
+			columns,
+			sortableBy,
+			sortScope,
+			discriminationField,
+		})
+		return (
+			<BoardMethodsContext.Provider value={methods}>
+				<BoardColumnsContext.Provider value={data.columns}>
+					{children}
+				</BoardColumnsContext.Provider>
+			</BoardMethodsContext.Provider>
+		)
+	},
+	({ entities, orderBy, limit, offset, columns, discriminationField, sortableBy, children }, env) => {
+		const childrenByType = boardAnalyzer.processChildren(children, env)
+		const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
+		return (
+			<>
+				<EntityListSubTree entities={entities} orderBy={orderBy} limit={limit} offset={offset}>
+					<Field {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
+					{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
+					{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</EntityListSubTree>
+			</>
+		)
+	},
+)
 
 export type BoardRelativeStaticProps =
 	& BoardCommonProps
 	& BoardStaticColumnsBindingProps
 	& BoardRelativeItemsProps
 
-const RelativeStaticBoard = Component<BoardRelativeStaticProps>(({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, sortScope, children }) => {
-	const itemsAccessor = useEntityList({ field, orderBy, limit, offset })
-	const [data, methods] = useStaticBoard({
-		itemEntities: itemsAccessor,
-		columns,
-		sortableBy,
-		sortScope,
-		discriminationField,
-	})
-	return (
-		<BoardMethodsContext.Provider value={methods}>
-			<BoardColumnsContext.Provider value={data.columns}>
-				{children}
-			</BoardColumnsContext.Provider>
-		</BoardMethodsContext.Provider>
-	)
-}, ({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, children }, env) => {
-	const childrenByType = boardAnalyzer.processChildren(children, env)
-	const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
-	return (<>
-		<HasMany field={field} orderBy={orderBy} limit={limit} offset={offset}>
-			<Field {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
-			{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
-			{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
-		</HasMany>
-	</>)
-})
+const RelativeStaticBoard = Component<BoardRelativeStaticProps>(
+	({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, sortScope, children }) => {
+		const itemsAccessor = useEntityList({ field, orderBy, limit, offset })
+		const [data, methods] = useStaticBoard({
+			itemEntities: itemsAccessor,
+			columns,
+			sortableBy,
+			sortScope,
+			discriminationField,
+		})
+		return (
+			<BoardMethodsContext.Provider value={methods}>
+				<BoardColumnsContext.Provider value={data.columns}>
+					{children}
+				</BoardColumnsContext.Provider>
+			</BoardMethodsContext.Provider>
+		)
+	},
+	({ field, orderBy, limit, offset, columns, discriminationField, sortableBy, children }, env) => {
+		const childrenByType = boardAnalyzer.processChildren(children, env)
+		const itemChildren = childrenByType.filter(it => it.type === 'item').map(it => it.children)
+		return (
+			<>
+				<HasMany field={field} orderBy={orderBy} limit={limit} offset={offset}>
+					<Field {...typeof discriminationField === 'string' ? { field: discriminationField } : discriminationField} />
+					{sortableBy && <Field {...typeof sortableBy === 'string' ? { field: sortableBy } : sortableBy} />}
+					{itemChildren.map((it, index) => <Fragment key={index}>{it}</Fragment>)}
+				</HasMany>
+			</>
+		)
+	},
+)

package/src/components/BoardEachColumn.tsx

@@ -10,22 +10,26 @@ export const BoardEachColumn = ({ children }: {
 }) => {
 	const columns = useBoardColumns()
 
-	return <>
-		{columns.map(column => {
-			if (column.id === BoardNullColumnPlaceholder) {
-				return null
-			}
-			return (
-				<BoardCurrentColumnContext.Provider value={column} key={column.id}>
-					{isEntityAccessor(column.value) ? (
-						<Entity accessor={column.value}>
-							{children}
-						</Entity>
-					) : children}
-				</BoardCurrentColumnContext.Provider>
-			)
-		})}
-	</>
+	return (
+		<>
+			{columns.map(column => {
+				if (column.id === BoardNullColumnPlaceholder) {
+					return null
+				}
+				return (
+					<BoardCurrentColumnContext.Provider value={column} key={column.id}>
+						{isEntityAccessor(column.value)
+							? (
+								<Entity accessor={column.value}>
+									{children}
+								</Entity>
+							)
+							: children}
+					</BoardCurrentColumnContext.Provider>
+				)
+			})}
+		</>
+	)
 }
 BoardEachColumn.staticRender = ({ children }: { children: ReactNode }) => {
 	return <BoardColumn>{children}</BoardColumn>

package/src/components/BoardEachItem.tsx

@@ -9,19 +9,21 @@ export const BoardEachItem = ({ children }: {
 }) => {
 	const currentColumn = useBoardCurrentColumn()
 
-	return <>
-		{currentColumn.items.map((item, index) => {
-			return (
-				<BoardEachItemInner
-					key={item.id}
-					item={item}
-					column={currentColumn}
-				>
-					{children}
-				</BoardEachItemInner>
-			)
-		})}
-	</>
+	return (
+		<>
+			{currentColumn.items.map((item, index) => {
+				return (
+					<BoardEachItemInner
+						key={item.id}
+						item={item}
+						column={currentColumn}
+					>
+						{children}
+					</BoardEachItemInner>
+				)
+			})}
+		</>
+	)
 }
 BoardEachItem.staticRender = ({ children }: { children: ReactNode }) => {
 	return <BoardItem>{children}</BoardItem>
@@ -31,7 +33,6 @@ const BoardEachItemInner = ({ children, item, column }: {
 	children: ReactNode
 	column: BoardColumnNode
 	item: BoardItemNode
-
 }) => {
 	const itemWithColumn = useMemo(() => ({
 		...item,

package/src/contexts.ts

@@ -6,7 +6,6 @@ const _BoardMethodsContext = createRequiredContext<BoardMethods<any>>('BoardMeth
 export const BoardMethodsContext = _BoardMethodsContext[0]
 export const useBoardMethods = _BoardMethodsContext[1] as <T extends BoardColumnValue = BoardColumnValue>() => BoardMethods<T>
 
-
 const BoardColumnsContext_ = createRequiredContext<BoardColumnNode[]>('BoardColumnsContext')
 /** @internal */
 export const BoardColumnsContext = BoardColumnsContext_[0]

package/src/internal/useBoardItemsMethods.ts

@@ -5,13 +5,13 @@ import {
 	EntityAccessor,
 	EntityListAccessor,
 	RelativeSingleField,
-	repairEntitiesOrder, sortEntities,
+	repairEntitiesOrder,
+	sortEntities,
 } from '@contember/react-binding'
 import { BoardColumnKey, UseGroupItemsByColumn } from './useGroupItemsByColumn'
 import { arrayMove } from '../utils/arrayMove'
 import { BoardAddItemMethod, BoardColumnValue, BoardMethods, BoardMoveItemMethod, BoardRemoveItemMethod } from '../types'
 
-
 export type UseBoardItemsMethodsProps<ColumnValue extends BoardColumnValue> = {
 	itemEntities: EntityListAccessor
 	connectItemToColumn: (item: EntityAccessor, column: ColumnValue | null) => void
@@ -33,7 +33,6 @@ export const useBoardItemsMethods = <ColumnValue extends BoardColumnValue>({
 	columnIdGetter,
 	sortScope = 'column',
 }: UseBoardItemsMethodsProps<ColumnValue>): BoardItemsMethods<ColumnValue> => {
-
 	const itemEntitiesEntitiesGetter = itemEntities.getAccessor
 
 	const getSortScopeItems = useCallback((column: string | number | null) => {
@@ -77,7 +76,6 @@ export const useBoardItemsMethods = <ColumnValue extends BoardColumnValue>({
 
 		const resolvedIndex = resolveScopedIndex(columnId, index) ?? sortScopeItems.length
 
-
 		itemEntities.createNewEntity((getEntity, options) => {
 			sortScopeItems.splice(resolvedIndex, 0, getEntity())
 			repairEntitiesOrder(desugaredSortableByField, sortScopeItems)
@@ -85,7 +83,6 @@ export const useBoardItemsMethods = <ColumnValue extends BoardColumnValue>({
 		})
 	}, [columnIdGetter, connectItemToColumn, desugaredSortableByField, getSortScopeItems, itemEntitiesEntitiesGetter, resolveScopedIndex])
 
-
 	const moveItem = useMemo<BoardMoveItemMethod<ColumnValue> | undefined>(() => {
 		if (!desugaredSortableByField) {
 			return undefined
@@ -105,7 +102,6 @@ export const useBoardItemsMethods = <ColumnValue extends BoardColumnValue>({
 				return
 			}
 
-
 			// sort scope is column
 			const itemEntities = itemEntitiesEntitiesGetter()
 			const groupedItems = groupItemsByColumn(itemEntities)
@@ -118,9 +114,18 @@ export const useBoardItemsMethods = <ColumnValue extends BoardColumnValue>({
 			const newColumnItems = groupedItems.get(columnId)?.slice() ?? []
 			newColumnItems.splice(index, 0, entity)
 			repairEntitiesOrder(desugaredSortableByField, newColumnItems)
-
 		}
-	}, [columnIdGetter, connectItemToColumn, desugaredSortableByField, getDiscriminatorValue, getSortScopeItems, groupItemsByColumn, itemEntitiesEntitiesGetter, resolveScopedIndex, sortScope])
+	}, [
+		columnIdGetter,
+		connectItemToColumn,
+		desugaredSortableByField,
+		getDiscriminatorValue,
+		getSortScopeItems,
+		groupItemsByColumn,
+		itemEntitiesEntitiesGetter,
+		resolveScopedIndex,
+		sortScope,
+	])
 
 	const removeItem = useCallback<BoardRemoveItemMethod>(entity => {
 		if (desugaredSortableByField) {

package/src/internal/useCreateBoardColumns.ts

@@ -10,7 +10,6 @@ export const useCreateBoardColumns = <ColumnValue extends BoardColumnValue>({ gr
 	columnIdGetter: (column: ColumnValue) => string | number
 	groupItemsByColumn: UseGroupItemsByColumn
 }): BoardColumnNode<ColumnValue>[] => {
-
 	return useMemo(() => {
 		const itemsByColumn = groupItemsByColumn(items)
 
@@ -25,7 +24,6 @@ export const useCreateBoardColumns = <ColumnValue extends BoardColumnValue>({ gr
 		]
 		let index = 0
 
-
 		for (const column of columns) {
 			result.push({
 				id: columnIdGetter(column),
@@ -35,6 +33,5 @@ export const useCreateBoardColumns = <ColumnValue extends BoardColumnValue>({ gr
 			})
 		}
 		return result
-
 	}, [columnIdGetter, columns, groupItemsByColumn, items])
 }

package/src/internal/useDynamicBoard.ts

@@ -10,12 +10,7 @@ import {
 	useDesugaredRelativeSingleEntity,
 	useDesugaredRelativeSingleField,
 } from '@contember/react-binding'
-import {
-	BoardAddColumnMethod,
-	BoardMethods,
-	BoardMoveColumnMethod,
-	BoardRemoveColumnMethod,
-} from '../types'
+import { BoardAddColumnMethod, BoardMethods, BoardMoveColumnMethod, BoardRemoveColumnMethod } from '../types'
 import { useGroupItemsByColumn } from './useGroupItemsByColumn'
 import { useCreateBoardColumns } from './useCreateBoardColumns'
 import { arrayMove } from '../utils/arrayMove'
@@ -23,7 +18,6 @@ import { useBoardItemsMethods } from './useBoardItemsMethods'
 import { BoardData } from '../types/BoardData'
 import { BoardCommonProps, BoardDynamicColumnsBindingProps } from '../components'
 
-
 export type UseDynamicBoardBindingProps =
 	& Omit<BoardCommonProps, 'children'>
 	& BoardDynamicColumnsBindingProps
@@ -46,15 +40,13 @@ export const useDynamicBoard = ({
 	columnEntities,
 	itemEntities,
 }: UseDynamicBoardBindingProps): [BoardData<EntityAccessor>, BoardMethods<EntityAccessor>] => {
-
 	const desugaredSortableByField = useDesugaredRelativeSingleField(sortableBy)
 	const desugaredColumnSortableByField = useDesugaredRelativeSingleField(columnsSortableBy)
 	const desugaredDiscriminationField = useDesugaredRelativeSingleEntity(discriminationField)
 
 	const columnEntitiesGetter = columnEntities.getAccessor
 
-
-	const exitingColumnIds = useMemo(() => new Set(Array.from(columnEntities).map(it => it.id)), [columnEntities])
+	const exitingColumnIds = useMemo(() => new Set(Array.from(columnEntities).map((it: EntityAccessor) => it.id)), [columnEntities])
 
 	const getDiscriminatorValue = useCallback((entity: EntityAccessor) => {
 		const entityId = entity.getEntity(desugaredDiscriminationField).id
@@ -91,10 +83,8 @@ export const useDynamicBoard = ({
 		} else {
 			parentEntity.disconnectEntityAtField(hasOne[hasOne.length - 1].field)
 		}
-
 	}, [desugaredDiscriminationField.hasOneRelationPath])
 
-
 	const moveColumn = useMemo<BoardMoveColumnMethod | undefined>(() => {
 		if (!desugaredColumnSortableByField) {
 			return undefined
@@ -107,7 +97,6 @@ export const useDynamicBoard = ({
 		}
 	}, [columnEntitiesGetter, desugaredColumnSortableByField, getSortedColumns])
 
-
 	const removeColumn = useCallback<BoardRemoveColumnMethod>(entity => {
 		entity.deleteEntity()
 		if (desugaredSortableByField) {

package/src/internal/useGroupItemsByColumn.ts

@@ -3,7 +3,10 @@ import { useCallback } from 'react'
 
 export type BoardColumnKey = string | EntityId | null
 export type UseGroupItemsByColumn = (itemEntities: EntityListAccessor) => Map<BoardColumnKey, EntityAccessor[]>
-export const useGroupItemsByColumn = (getDiscriminatorValue: (entity: EntityAccessor) => BoardColumnKey, sortBy: RelativeSingleField | undefined): UseGroupItemsByColumn => {
+export const useGroupItemsByColumn = (
+	getDiscriminatorValue: (entity: EntityAccessor) => BoardColumnKey,
+	sortBy: RelativeSingleField | undefined,
+): UseGroupItemsByColumn => {
 	return useCallback((itemEntities: EntityListAccessor) => {
 		const itemsByColumn = new Map<BoardColumnKey, EntityAccessor[]>()
 

package/src/internal/useStaticBoard.ts

@@ -7,7 +7,6 @@ import { useBoardItemsMethods } from './useBoardItemsMethods'
 import { BoardData } from '../types/BoardData'
 import { BoardCommonProps, BoardStaticColumnsBindingProps } from '../components'
 
-
 export type UseStaticBoardBindingProps =
 	& Omit<BoardCommonProps, 'children'>
 	& BoardStaticColumnsBindingProps
@@ -22,7 +21,6 @@ export const useStaticBoard = ({
 	discriminationField,
 	itemEntities,
 }: UseStaticBoardBindingProps): [BoardData<BoardStaticColumnValue>, BoardMethods<BoardStaticColumnValue>] => {
-
 	const desugaredSortableByField = useDesugaredRelativeSingleField(sortableBy)
 	const desugaredDiscriminationField = useDesugaredRelativeSingleField(discriminationField)