ci: apply automated fixes

Author: autofix-ci[bot]

packages/angular-table/src/angularReactivityFeature.ts

@@ -36,7 +36,7 @@ type SkipPropertyFn = (property: string) => boolean
  * - `true` enables wrapping using the default skip rules.
  * - `false` disables wrapping entirely for that object type.
  * - a function allows customizing the skip rules (see {@link SkipPropertyFn}).
- * 
+ *
  * @example
  * ```ts
  * const table = injectTable(() => {
@@ -207,9 +207,9 @@ function constructAngularReactivityFeature<
 }
 
 /**
- * Angular reactivity feature that add reactive signal supports in table core instance. 
+ * Angular reactivity feature that add reactive signal supports in table core instance.
  * This is used internally by the Angular table adapter `injectTable`.
- * 
+ *
  * @private
  */
 export const angularReactivityFeature = constructAngularReactivityFeature()

packages/angular-table/src/index.ts

@@ -16,10 +16,10 @@ export * from './helpers/flexRenderCell'
 
 /**
  * Constant helper to import FlexRender directives.
- * 
+ *
  * You should prefer to use this constant over importing the directives separately,
  * as it ensures you always have the correct set of directives over library updates.
- * 
+ *
  * @see {@link FlexRenderDirective} and {@link FlexRenderCell} for more details on the directives included in this export.
  */
 export const FlexRender = [FlexRenderDirective, FlexRenderCell] as const

packages/angular-table/src/injectTable.ts

@@ -39,47 +39,47 @@ export type AngularTable<
 
 /**
  * Creates and returns an Angular-reactive table instance.
- * 
+ *
  * The initializer is intentionally re-evaluated whenever any signal read inside it changes.
  * This is how the adapter keeps the table in sync with Angular's reactivity model.
  *
  * Because of that behavior, keep expensive/static values (for example `columns`, feature setup, row models)
- * as stable references outside the initializer, and only read reactive state (`data()`, pagination/filter/sorting signals, etc.) 
+ * as stable references outside the initializer, and only read reactive state (`data()`, pagination/filter/sorting signals, etc.)
  * inside it.
  *
  * The returned table is also signal-reactive: table state and table APIs are wired for Angular signals, so you can safely consume table methods inside `computed(...)` and `effect(...)`.
- * 
+ *
  * @example
  * 1. Register the table features you need
  * ```ts
  * // Register only the features you need
  * import {tableFeatures, rowPaginationFeature} from '@tanstack/angular-table';
- * const _features = tableFeatures({ 
+ * const _features = tableFeatures({
  *  rowPaginationFeature,
  *  // ...all other features you need
  * })
- * 
+ *
  * // Use all table core features
  * import {stockFeatures} from '@tanstack/angular-table';
  * const _features = tableFeatures(stockFeatures);
  * ```
  * 2. Prepare the table columns
  * ```ts
  * import {ColumnDef} from '@tanstack/angular-table';
- * 
+ *
  * type MyData = {}
- * 
+ *
  * const columns: ColumnDef<typeof _features, MyData>[] = [
  *   // ...column definitions
  * ]
- * 
+ *
  * // or using createColumnHelper
  * import {createColumnHelper} from '@tanstack/angular-table';
  * const columnHelper = createColumnHelper<typeof _features, MyData>();
  * const columns = columnHelper.columns([
  *  columnHelper.accessor(...),
  *  // ...other columns
- * ]) 
+ * ])
  * ```
  * 3. Create the table instance with `injectTable`
  * ```ts
@@ -90,7 +90,7 @@ export type AngularTable<
  *   data: myDataSignal(),
  * })
  * ```
- * 
+ *
  * @returns An Angular-reactive TanStack Table instance.
  */
 export function injectTable<