@blueprint-ts/core 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## v1.2.0 - 2026-01-25
+
+# [1.2.0](/compare/v1.1.2...v1.2.0) (2026-01-25)
+
+
+### Features
+
+* Added state paginator feature 87a9466
+## v1.1.2 - 2026-01-09
+
+## [1.1.2](/compare/v1.1.1...v1.1.2) (2026-01-09)
+
+
+### Bug Fixes
+
+* Adjusted PropertyAware type 893f705
+* Change @ts-expect-error to @ts-ignore to prevent errors in consuming projects 346a5b0
 ## v1.1.1 - 2026-01-08
 
 ## [1.1.1](/compare/v1.1.0...v1.1.1) (2026-01-08)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueprint-ts/core",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"

package/src/service/pagination/BasePaginator.ts

@@ -0,0 +1,36 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+
+export abstract class BasePaginator<ResourceInterface, ViewDriver extends BaseViewDriverContract<ResourceInterface[]>> {
+  protected initialized: boolean = false
+
+  protected abstract viewDriver: ViewDriver
+
+  public constructor(protected dataDriver: unknown) {}
+
+  public isInitialized(): boolean {
+    return this.initialized
+  }
+
+  public flush(): void {
+    this.viewDriver.setData([])
+  }
+
+  public getPageData(): ResourceInterface[] {
+    return this.viewDriver.getData()
+  }
+
+  public getTotal(): number {
+    return this.viewDriver.getTotal()
+  }
+
+  protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void {
+    if (options?.flush) {
+      this.flush()
+    }
+
+    this.viewDriver.setData(dto.getData())
+    this.viewDriver.setTotal(dto.getTotal())
+  }
+}

package/src/service/pagination/InfiniteScroller.ts

@@ -1,8 +1,8 @@
-import { Paginator } from './Paginator'
+import { PageAwarePaginator } from './PageAwarePaginator'
 import { PaginationDataDto } from './dtos/PaginationDataDto'
 import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
 
-export class InfiniteScroller<ResourceInterface> extends Paginator<ResourceInterface> {
+export class InfiniteScroller<ResourceInterface> extends PageAwarePaginator<ResourceInterface> {
   protected override passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options: PaginatorLoadDataOptions = {}) {
     const { flush = false, replace = false } = options
 

package/src/service/pagination/PageAwarePaginator.ts

@@ -0,0 +1,124 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { type ViewDriverContract } from './contracts/ViewDriverContract'
+import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
+import { BasePaginator } from './BasePaginator'
+
+export interface PageAwarePaginatorOptions {
+  viewDriverFactory?: ViewDriverFactoryContract
+}
+
+export class PageAwarePaginator<ResourceInterface> extends BasePaginator<ResourceInterface, ViewDriverContract<ResourceInterface[]>> {
+  protected static viewDriverFactory: ViewDriverFactoryContract
+
+  protected override viewDriver: ViewDriverContract<ResourceInterface[]>
+
+  public static setViewDriverFactory(value: ViewDriverFactoryContract): void {
+    PageAwarePaginator.viewDriverFactory = value
+  }
+
+  public constructor(
+    protected override dataDriver: PaginationDataDriverContract<ResourceInterface[]>,
+    pageNumber: number = 1,
+    pageSize: number = 10,
+    options?: PageAwarePaginatorOptions
+  ) {
+    super(dataDriver)
+    this.viewDriver = options?.viewDriverFactory
+      ? options.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
+      : PageAwarePaginator.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
+  }
+
+  public setDataDriver(dataDriver: PaginationDataDriverContract<ResourceInterface[]>): this {
+    this.dataDriver = dataDriver
+
+    return this
+  }
+
+  public getDataDriver(): PaginationDataDriverContract<ResourceInterface[]> {
+    return this.dataDriver
+  }
+
+  public init(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.initialized = true
+
+    if (pageNumber && pageSize) {
+      return this.loadData(pageNumber, pageSize)
+    }
+
+    return this.loadData(this.getCurrentPage(), this.getPageSize())
+  }
+
+  public refresh(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    if (pageNumber !== undefined) {
+      return this.setPage(pageNumber, options)
+    }
+
+    return this.loadData(this.getCurrentPage(), this.getPageSize(), options)
+  }
+
+  public setPage(pageNumber: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.viewDriver.setPage(pageNumber)
+
+    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize(), options)
+  }
+
+  public getLastPage(): number {
+    return this.viewDriver.getLastPage()
+  }
+
+  public toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.getCurrentPage() + 1)
+  }
+
+  public toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(1)
+  }
+
+  public toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.viewDriver.getLastPage())
+  }
+
+  public toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.getCurrentPage() - 1)
+  }
+
+  public getCurrentPage(): number {
+    return this.viewDriver.getCurrentPage()
+  }
+
+  public getFromItemNumber(): number {
+    return (this.getCurrentPage() - 1) * this.getPageSize() + 1
+  }
+
+  public getToItemNumber(): number {
+    return this.getCurrentPage() * this.getPageSize()
+  }
+
+  public getPageSize(): number {
+    return this.viewDriver.getPageSize()
+  }
+
+  public setPageSize(pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.viewDriver.setPageSize(pageSize)
+
+    if (this.getCurrentPage() * pageSize > this.getTotal()) {
+      return this.setPage(1)
+    }
+
+    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize())
+  }
+
+  public getPages(): number[] {
+    return this.viewDriver.getPages()
+  }
+
+  protected loadData(pageNumber: number, pageSize: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.dataDriver.get(pageNumber, pageSize).then((value: PaginationDataDto<ResourceInterface[]>) => {
+      this.passDataToViewDriver(value, options)
+
+      return value
+    })
+  }
+}

package/src/service/pagination/Paginator.ts

@@ -1,149 +1,11 @@
-import { PaginationDataDto } from './dtos/PaginationDataDto'
-import { type ViewDriverContract } from './contracts/ViewDriverContract'
-import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract'
-import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
-import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
+import { PageAwarePaginator, type PageAwarePaginatorOptions } from './PageAwarePaginator'
 
-export interface PaginatorOptions {
-  viewDriverFactory?: ViewDriverFactoryContract
-}
+/**
+ * @deprecated Use PageAwarePaginator instead. This alias is kept for backward compatibility.
+ */
+export const Paginator = PageAwarePaginator
 
-export class Paginator<ResourceInterface> {
-  protected initialized: boolean = false
-
-  protected static viewDriverFactory: ViewDriverFactoryContract
-
-  protected viewDriver: ViewDriverContract<ResourceInterface[]>
-
-  public static setViewDriverFactory(value: ViewDriverFactoryContract): void {
-    Paginator.viewDriverFactory = value
-  }
-
-  public constructor(
-    protected dataDriver: PaginationDataDriverContract<ResourceInterface[]>,
-    pageNumber: number = 1,
-    pageSize: number = 10,
-    options?: PaginatorOptions
-  ) {
-    this.viewDriver = options?.viewDriverFactory
-      ? options.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
-      : Paginator.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
-  }
-
-  public setDataDriver(dataDriver: PaginationDataDriverContract<ResourceInterface[]>): this {
-    this.dataDriver = dataDriver
-
-    return this
-  }
-
-  public getDataDriver(): PaginationDataDriverContract<ResourceInterface[]> {
-    return this.dataDriver
-  }
-
-  public init(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.initialized = true
-
-    if (pageNumber && pageSize) {
-      return this.loadData(pageNumber, pageSize)
-    }
-
-    return this.loadData(this.getCurrentPage(), this.getPageSize())
-  }
-
-  public refresh(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
-    if (pageNumber !== undefined) {
-      return this.setPage(pageNumber, options)
-    }
-
-    return this.loadData(this.getCurrentPage(), this.getPageSize(), options)
-  }
-
-  public flush(): void {
-    this.viewDriver.setData([])
-  }
-
-  public setPage(pageNumber: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.viewDriver.setPage(pageNumber)
-
-    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize(), options)
-  }
-
-  public isInitialized(): boolean {
-    return this.initialized
-  }
-
-  public getLastPage(): number {
-    return this.viewDriver.getLastPage()
-  }
-
-  public toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.getCurrentPage() + 1)
-  }
-
-  public toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(1)
-  }
-
-  public toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.viewDriver.getLastPage())
-  }
-
-  public toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.getCurrentPage() - 1)
-  }
-
-  public getPageData(): ResourceInterface[] {
-    return this.viewDriver.getData()
-  }
-
-  public getCurrentPage(): number {
-    return this.viewDriver.getCurrentPage()
-  }
-
-  public getFromItemNumber(): number {
-    return (this.getCurrentPage() - 1) * this.getPageSize() + 1
-  }
-
-  public getToItemNumber(): number {
-    return this.getCurrentPage() * this.getPageSize()
-  }
-
-  public getTotal(): number {
-    return this.viewDriver.getTotal()
-  }
-
-  public getPageSize(): number {
-    return this.viewDriver.getPageSize()
-  }
-
-  public setPageSize(pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.viewDriver.setPageSize(pageSize)
-
-    if (this.getCurrentPage() * pageSize > this.getTotal()) {
-      return this.setPage(1)
-    }
-
-    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize())
-  }
-
-  public getPages(): number[] {
-    return this.viewDriver.getPages()
-  }
-
-  protected loadData(pageNumber: number, pageSize: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.dataDriver.get(pageNumber, pageSize).then((value: PaginationDataDto<ResourceInterface[]>) => {
-      this.passDataToViewDriver(value, options)
-
-      return value
-    })
-  }
-
-  protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void {
-    if (options?.flush) {
-      this.flush()
-    }
-
-    this.viewDriver.setData(dto.getData())
-    this.viewDriver.setTotal(dto.getTotal())
-  }
-}
+/**
+ * @deprecated Use PageAwarePaginatorOptions instead. This alias is kept for backward compatibility.
+ */
+export type PaginatorOptions = PageAwarePaginatorOptions

package/src/service/pagination/StatePaginator.ts

@@ -0,0 +1,92 @@
+import { StatePaginationDataDto } from './dtos/StatePaginationDataDto'
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract'
+import { type BaseViewDriverFactoryContract } from './contracts/BaseViewDriverFactoryContract'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+import { type StatePaginationDataDriverContract } from './contracts/StatePaginationDataDriverContract'
+import { BasePaginator } from './BasePaginator'
+
+export interface StatePaginatorOptions {
+  viewDriverFactory?: BaseViewDriverFactoryContract
+}
+
+export class StatePaginator<ResourceInterface> extends BasePaginator<ResourceInterface, BaseViewDriverContract<ResourceInterface[]>> {
+  protected static viewDriverFactory: BaseViewDriverFactoryContract
+
+  protected override viewDriver: BaseViewDriverContract<ResourceInterface[]>
+
+  protected currentState: string | null = null
+
+  public static setViewDriverFactory(value: BaseViewDriverFactoryContract): void {
+    StatePaginator.viewDriverFactory = value
+  }
+
+  public constructor(
+    protected override dataDriver: StatePaginationDataDriverContract<ResourceInterface[]>,
+    options?: StatePaginatorOptions
+  ) {
+    super(dataDriver)
+    this.viewDriver = options?.viewDriverFactory
+      ? options.viewDriverFactory.make<ResourceInterface>()
+      : StatePaginator.viewDriverFactory.make<ResourceInterface>()
+  }
+
+  public setDataDriver(dataDriver: StatePaginationDataDriverContract<ResourceInterface[]>): this {
+    this.dataDriver = dataDriver
+
+    return this
+  }
+
+  public getDataDriver(): StatePaginationDataDriverContract<ResourceInterface[]> {
+    return this.dataDriver
+  }
+
+  public init(): Promise<StatePaginationDataDto<ResourceInterface[]>> {
+    this.initialized = true
+    this.currentState = null
+
+    return this.loadData()
+  }
+
+  public refresh(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>> {
+    this.currentState = null
+
+    return this.loadData({ ...options, flush: true })
+  }
+
+  public loadNext(): Promise<StatePaginationDataDto<ResourceInterface[]>> {
+    return this.loadData()
+  }
+
+  public hasNextPage(): boolean {
+    return this.currentState !== null
+  }
+
+  public getCurrentState(): string | null {
+    return this.currentState
+  }
+
+  protected loadData(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>> {
+    return this.dataDriver.get(this.currentState).then((value: StatePaginationDataDto<ResourceInterface[]>) => {
+      this.currentState = value.getState()
+      this.passStateDataToViewDriver(value, options)
+
+      return value
+    })
+  }
+
+  protected passStateDataToViewDriver(dto: StatePaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void {
+    const { flush = false, replace = false } = options || {}
+
+    if (flush) {
+      this.flush()
+    }
+
+    if (replace) {
+      this.viewDriver.setData(dto.getData())
+    } else {
+      this.viewDriver.setData(this.viewDriver.getData().concat(dto.getData()))
+    }
+
+    this.viewDriver.setTotal(dto.getTotal())
+  }
+}

package/src/service/pagination/contracts/BaseViewDriverContract.ts

@@ -0,0 +1,6 @@
+export interface BaseViewDriverContract<ResourceInterface> {
+  setData(data: ResourceInterface): void
+  getData(): ResourceInterface
+  setTotal(value: number): void
+  getTotal(): number
+}

package/src/service/pagination/contracts/BaseViewDriverFactoryContract.ts

@@ -0,0 +1,5 @@
+import { type BaseViewDriverContract } from './BaseViewDriverContract'
+
+export interface BaseViewDriverFactoryContract {
+  make<ResourceInterface>(): BaseViewDriverContract<ResourceInterface[]>
+}

package/src/service/pagination/contracts/StatePaginationDataDriverContract.ts

@@ -0,0 +1,5 @@
+import { StatePaginationDataDto } from '../dtos/StatePaginationDataDto'
+
+export interface StatePaginationDataDriverContract<ResourceInterface> {
+  get(state?: string | null): Promise<StatePaginationDataDto<ResourceInterface>>
+}

package/src/service/pagination/contracts/ViewDriverContract.ts

@@ -1,12 +1,10 @@
-export interface ViewDriverContract<ResourceInterface> {
-  setData(data: ResourceInterface): void
-  setTotal(value: number): void
-  getData(): ResourceInterface
+import { type BaseViewDriverContract } from './BaseViewDriverContract'
+
+export interface ViewDriverContract<ResourceInterface> extends BaseViewDriverContract<ResourceInterface> {
   getCurrentPage(): number
   setPage(value: number): void
   setPageSize(value: number): void
   getPageSize(): number
   getLastPage(): number
   getPages(): number[]
-  getTotal(): number
 }

package/src/service/pagination/dtos/StatePaginationDataDto.ts

@@ -0,0 +1,19 @@
+import { PaginationDataDto } from './PaginationDataDto'
+
+export class StatePaginationDataDto<ResourceInterface> extends PaginationDataDto<ResourceInterface> {
+  public constructor(
+    data: ResourceInterface,
+    total: number,
+    protected state: string | null = null
+  ) {
+    super(data, total)
+  }
+
+  public getState(): string | null {
+    return this.state
+  }
+
+  public hasNextPage(): boolean {
+    return this.state !== null
+  }
+}

package/src/service/pagination/factories/VueBaseViewDriverFactory.ts

@@ -0,0 +1,9 @@
+import { type BaseViewDriverFactoryContract } from '../contracts/BaseViewDriverFactoryContract'
+import { type BaseViewDriverContract } from '../contracts/BaseViewDriverContract'
+import { VueBaseViewDriver } from '../frontendDrivers/VueBaseViewDriver'
+
+export class VueBaseViewDriverFactory implements BaseViewDriverFactoryContract {
+  public make<ResourceInterface>(): BaseViewDriverContract<ResourceInterface[]> {
+    return new VueBaseViewDriver<ResourceInterface>()
+  }
+}

package/src/service/pagination/frontendDrivers/VueBaseViewDriver.ts

@@ -0,0 +1,28 @@
+import { ref, type Ref } from 'vue'
+import { type BaseViewDriverContract } from '../contracts/BaseViewDriverContract'
+
+export class VueBaseViewDriver<ResourceInterface> implements BaseViewDriverContract<ResourceInterface[]> {
+  protected dataRef: Ref<ResourceInterface[]>
+  protected totalRef: Ref<number>
+
+  public constructor() {
+    this.dataRef = ref([]) as Ref<ResourceInterface[]>
+    this.totalRef = ref<number>(0)
+  }
+
+  public setData(data: ResourceInterface[]): void {
+    this.dataRef.value = data
+  }
+
+  public getData(): ResourceInterface[] {
+    return this.dataRef.value
+  }
+
+  public setTotal(value: number): void {
+    this.totalRef.value = value
+  }
+
+  public getTotal(): number {
+    return this.totalRef.value
+  }
+}

package/src/service/pagination/index.ts

@@ -1,16 +1,48 @@
 import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { StatePaginationDataDto } from './dtos/StatePaginationDataDto'
 import { VuePaginationDriver } from './frontendDrivers/VuePaginationDriver'
+import { VueBaseViewDriver } from './frontendDrivers/VueBaseViewDriver'
 import { Paginator } from './Paginator'
+import { BasePaginator } from './BasePaginator'
+import { PageAwarePaginator } from './PageAwarePaginator'
+import { StatePaginator } from './StatePaginator'
 import { InfiniteScroller } from './InfiniteScroller'
 import { VuePaginationDriverFactory } from './factories/VuePaginationDriverFactory'
+import { VueBaseViewDriverFactory } from './factories/VueBaseViewDriverFactory'
 import { type PaginateableRequestContract } from './contracts/PaginateableRequestContract'
 import { type PaginationResponseContract } from './contracts/PaginationResponseContract'
 import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
+import { type StatePaginationDataDriverContract } from './contracts/StatePaginationDataDriverContract'
 import { getDisplayablePages } from '../../helpers'
 import { ArrayDriver } from './dataDrivers/ArrayDriver'
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract'
 import { type ViewDriverContract } from './contracts/ViewDriverContract'
+import { type BaseViewDriverFactoryContract } from './contracts/BaseViewDriverFactoryContract'
 import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract'
 
-export { PaginationDataDto, VuePaginationDriver, Paginator, InfiniteScroller, VuePaginationDriverFactory, getDisplayablePages, ArrayDriver }
+export {
+  PaginationDataDto,
+  StatePaginationDataDto,
+  VuePaginationDriver,
+  VueBaseViewDriver,
+  Paginator,
+  BasePaginator,
+  PageAwarePaginator,
+  StatePaginator,
+  InfiniteScroller,
+  VuePaginationDriverFactory,
+  VueBaseViewDriverFactory,
+  getDisplayablePages,
+  ArrayDriver
+}
 
-export type { PaginationDataDriverContract, PaginationResponseContract, PaginateableRequestContract, ViewDriverContract, ViewDriverFactoryContract }
+export type {
+  PaginationDataDriverContract,
+  StatePaginationDataDriverContract,
+  PaginationResponseContract,
+  PaginateableRequestContract,
+  BaseViewDriverContract,
+  ViewDriverContract,
+  BaseViewDriverFactoryContract,
+  ViewDriverFactoryContract
+}

package/src/vue/forms/PropertyAwareArray.ts

@@ -1,10 +1,10 @@
+import { type WritableComputedRef } from 'vue'
+
 /**
  * Repräsentiert eine reaktive Property mit model.value Zugriff
  */
 export interface PropertyAwareField<T> {
-  model: {
-    value: T
-  }
+  model: WritableComputedRef<T>
   errors: any[]
   suggestions: any[]
   dirty: boolean
@@ -15,7 +15,7 @@ export interface PropertyAwareField<T> {
  * Jedes Feld vom Typ T wird zu einem PropertyAwareField<T>
  */
 export type PropertyAware<T> = {
-  [K in keyof T]: T[K] extends Array<infer U> ? Array<PropertyAware<U>> : PropertyAwareField<T[K]>
+  [K in keyof T]: PropertyAwareField<T[K]>
 }
 /**
  * Extends Array with property awareness.

package/src/vue/state/State.ts

@@ -262,7 +262,7 @@ export abstract class State<T extends object> {
 
         for (let i = 1; i < pathParts.length; i++) {
           if (!obj || typeof obj !== 'object') return undefined
-          // @ts-expect-error: obj is guaranteed to be an object at this point
+          // @ts-ignore: obj is guaranteed to be an object at this point
           obj = (obj as any)[pathParts[i]]
         }