{"version":3,"file":"app-e148aa39.f584a1446b2fc034d810.bundle.js","mappings":"AAAA","sources":["webpack://lernplattform-admin-frontend/../common/aurelia-decorators/select-state/dependency-and-state-observer.ts","webpack://lernplattform-admin-frontend/../common/aurelia-decorators/select-state/dependency-expression.ts","webpack://lernplattform-admin-frontend/../common/aurelia-decorators/select-state/dependency.ts","webpack://lernplattform-admin-frontend/../common/aurelia-decorators/select-state/index.ts","webpack://lernplattform-admin-frontend/../common/aurelia-decorators/select-state/select-state-observable-component.ts"],"sourcesContent":["import { Container } from 'aurelia-framework';\nimport {\n  ObserverLocator,\n  subscriberCollection,\n  connectable as $connectable,\n  Scope,\n  createOverrideContext,\n  Binding,\n  Disposable,\n} from 'aurelia-binding';\nimport { StoreService, UpdateDependencyObjectCallback } from 'common/aurelia-services/StoreService';\nimport { assertNotNullOrUndefined } from 'common/utils/assert';\nimport {\n  ICallable,\n  IDependency,\n  ISelectStateOptions,\n  ISelectStatePropertyDescriptor,\n  SelectorCreator,\n} from './definitions';\nimport { DependencyExpression } from './dependency-expression';\nimport { getDependency, releaseDep } from './dependency';\n\n// copied and edited from https://github.com/bigopon/aurelia-deep-computed\n\n/**\n * @internal The interface describes methods added by `connectable` & `subscriberCollection` decorators\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unused-vars\nexport interface DependencyAndStateObserver<TState, TSelected, TDependencyObject> extends Binding {\n  _version: number;\n  addSubscriber(callable: (...args: any[]) => void): boolean;\n  addSubscriber(context: string, callable: ICallable): boolean;\n  addSubscriber(context: string | ICallable, callable?: ICallable): boolean;\n  callSubscribers(newValue: any, oldValue?: any): void;\n  hasSubscriber(context: string | ICallable, callable?: ICallable): boolean;\n  hasSubscribers(): boolean;\n  removeSubscriber(context: string | ICallable, callable?: ICallable): boolean;\n  observe(): void;\n  unobserve(all?: boolean): void;\n}\n\n// it looks better using @...(), so we cast to any instead of ClassDecorator\n// aurelia decorators support both usage: with and without parens\nconst connectable = $connectable as any;\n\nexport class DependencyAndStateObserver<TState, TSelected, TDependencyObject> {\n  private isQueued = false;\n  private rootDeps: Array<IDependency> | null = null;\n  private readonly scope: Scope;\n  private readonly notifyingDeps: Array<IDependency> = [];\n  private currentValue?: TSelected;\n  private $get: () => TSelected;\n  private $set: (newValue: TSelected | undefined) => void;\n  private observing = false;\n  private selectorCreator: SelectorCreator<TState, TSelected, TDependencyObject>;\n  private storeService: StoreService<TState> | null = null;\n  private oldValue?: TSelected;\n  private updateDependencyObjectCallback: UpdateDependencyObjectCallback<TDependencyObject> | null = null;\n\n  constructor(\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    public obj: object,\n    // this expression has 1 purpose:\n    //  - an abstraction for dealing with a list of declared dependencies and their corresponding value\n    //    that uses existing Aurelia binding capabilities\n    public expression: DependencyExpression,\n    public observerLocator: ObserverLocator,\n    descriptor: ISelectStatePropertyDescriptor<TState, TSelected, TDependencyObject>,\n    selectStateOptions: ISelectStateOptions<TState, TSelected, TDependencyObject>,\n  ) {\n    this.scope = { bindingContext: obj, overrideContext: createOverrideContext(obj) };\n    this.selectorCreator = selectStateOptions.selectorCreator;\n\n    const propertyName = expression.name;\n    const getterFn = (\n      // not observing === no track === no confidence that the current value is correct\n      () => (this.observing ? this.currentValue : this.$get())\n    ) as ISelectStatePropertyDescriptor<TState, TSelected, TDependencyObject>['get'];\n\n    Object.defineProperty(obj, propertyName, {\n      get: getterFn,\n      configurable: true,\n      enumerable: true,\n    });\n\n    this.$get = () => {\n      return descriptor.get.call(obj);\n    };\n\n    this.$set = newValue => {\n      descriptor.set.call(obj, newValue);\n    };\n  }\n\n  public getValue(): TSelected | undefined {\n    return this.observing\n      ? this.currentValue\n      : this.$get();\n  }\n\n  public setValue(newValue: TSelected | undefined): void {\n    this.currentValue = newValue;\n    this.$set(newValue);\n    this.callSubscribers(newValue, this.oldValue);\n    this.oldValue = newValue;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n  public subscribe(context: any, callable?: ICallable): void | Disposable {\n    if(this.storeService == null) {\n      this.storeService = Container.instance.get(StoreService) as StoreService<TState>;\n    }\n\n    if(!this.hasSubscribers()) {\n      this.oldValue = this.$get();\n      this.expression.connect(/* @connectable makes this class behave as Binding */ this, this.scope);\n      this.observeDeps();\n      this.observing = true;\n      const initialDependencyObject = this.evaluateDependencyObject();\n      this.updateDependencyObjectCallback = this.subscribeToState(initialDependencyObject);\n    }\n    this.addSubscriber(context, callable);\n\n    // scenario where this observer is created manually via ObserverLocator.getObserver\n    if(arguments.length === 1 && typeof context === 'function') {\n      return {\n        dispose: () => {\n          this.unsubscribe(context, callable);\n        },\n      };\n    }\n\n    return undefined;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n  public unsubscribe(context: any, callable?: ICallable): void {\n    if(this.removeSubscriber(context, callable) && !this.hasSubscribers()) {\n      this.storeService?.disposeAllSubscriptions(this);\n      this.observing = false;\n      this.unobserveDeps();\n      this.notifyingDeps.length = 0;\n      this.unobserve(true);\n      this.oldValue = undefined;\n    }\n  }\n\n  public call(): void {\n    this.evaluateDependencyObject();\n    if(this.isQueued) {\n      this.notifyingDeps.forEach(dep => {\n        if(!dep.connected) {\n          return;\n        }\n        dep.release();\n        dep.collect();\n        dep.observe();\n      });\n      this.isQueued = false;\n    } else {\n      this.unobserveDeps();\n      this.observeDeps();\n    }\n    this.notifyingDeps.length = 0;\n    // eslint-disable-next-line no-underscore-dangle\n    this._version++;\n    this.expression.connect(/* @connectable makes this class behave as Binding */this, this.scope);\n    this.unobserve(false);\n  }\n\n  public handleChange(dep: IDependency): void {\n    const { notifyingDeps } = this;\n    if(notifyingDeps.indexOf(dep) === -1) {\n      notifyingDeps.push(dep);\n    }\n    if(this.isQueued) {\n      return;\n    }\n    this.isQueued = true;\n    this.observerLocator.taskQueue.queueMicroTask(this);\n  }\n\n  private observeDeps(): void {\n    const values = this.expression.getDeps(this.scope);\n    if(this.rootDeps == null) {\n      this.rootDeps = values.map(v => getDependency(this, null, v)).filter((dep): dep is IDependency => dep != null);\n    }\n    for(const dep of this.rootDeps) {\n      dep.collect();\n      dep.observe();\n    }\n  }\n\n  private unobserveDeps(): void {\n    const { rootDeps } = this;\n    if(rootDeps != null) {\n      rootDeps.forEach(releaseDep);\n      this.rootDeps = null;\n    }\n  }\n\n  private evaluateDependencyObject(): TDependencyObject {\n    const deps = this.expression.getDeps(this.scope);\n    const dependencyObject = deps.reduce<{ [key: string]: any }>((acc, dep) => ({ ...acc, [dep.name]: dep.value }), { }) as TDependencyObject;\n\n    this.updateDependencyObjectCallback?.(dependencyObject);\n    return dependencyObject;\n  }\n\n  private subscribeToState(initialDependencyObject: TDependencyObject): UpdateDependencyObjectCallback<TDependencyObject> {\n    assertNotNullOrUndefined(this.storeService, 'expected storeService to be initiated at that point');\n    this.storeService.disposeAllSubscriptions(this);\n\n    return this.storeService.subscribeToStateWithDependencyObject(\n      this,\n      this.selectorCreator,\n      newValue => this.setValue(newValue),\n      initialDependencyObject,\n    );\n  }\n}\n\n// use this instead of decorator to avoid extra generated code\nconnectable()(DependencyAndStateObserver);\nsubscriberCollection()(DependencyAndStateObserver);\n","import { Expression, Scope, Binding } from 'aurelia-binding';\n\nexport class DependencyExpression extends Expression {\n  // this is to signal aurelia binding that it's ok trying to invoke .assign on this expression\n  public isAssignable = true;\n\n  constructor(\n    public readonly name: string,\n    public readonly dependencies: Array<Expression & { name: string }>,\n  ) {\n    super();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/explicit-module-boundary-types\n  public evaluate(scope: Scope, lookupFunctions: any): any {\n    return scope.bindingContext[this.name];\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/explicit-module-boundary-types\n  public assign(scope: Scope, value: any, _lookupFunctions?: any): void {\n    scope.bindingContext[this.name] = value;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/explicit-module-boundary-types\n  public accept(visitor: any): void {\n    throw new Error('not implemented');\n  }\n\n  public connect(binding: Binding, scope: Scope): void {\n    const { dependencies } = this;\n    let i = dependencies.length;\n    while(i--) {\n      dependencies[i].connect(binding, scope);\n    }\n  }\n\n  public getDeps(scope: Scope): Array<IDependencyValue> {\n    return this.dependencies.map(dep => ({ name: dep.name, value: dep.evaluate(scope) }));\n  }\n}\n\ninterface IDependencyValue {\n  name: string;\n  value: any;\n}\n","import { ICollectionObserverSplice } from 'aurelia-binding';\nimport {\n  IPropertyObserver,\n  ICollectionObserver,\n  IDependency,\n  IDependencyAndStateObserver,\n  ICollectionDependency,\n} from './definitions';\n\n/** @internal */\nexport const releaseDep = (dep: IDependency): void => {\n  dep.release();\n};\n\n/** @internal */\nexport const observeDep = (dep: IDependency): void => {\n  dep.observe();\n};\n\n// for Aurelia binding subscriber, a context is required if it's not a function\nconst objectPropDepContext = 'context:object_prop_dep';\nconst arrayDepContext = 'context:array_dep';\nconst setDepContext = 'context:set_dep';\nconst mapDepContext = 'context:map_dep';\n\nclass ObjectDependency implements IDependency {\n  deps: Map<string | number, IDependency> = new Map();\n  connected = false;\n  constructor(\n    public owner: IDependencyAndStateObserver,\n    public parent: IDependency | null,\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    public value: object,\n  ) { }\n\n  public collect(): void {\n    const { value } = this;\n    Object.keys(value).forEach(prop => {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      const propertyDep = new ObjectPropertyDependency(this.owner, this, prop, value[prop]);\n      this.deps.set(prop, propertyDep);\n      propertyDep.collect();\n    });\n  }\n\n  public observe(): void {\n    this.deps.forEach(observeDep);\n    this.connected = true;\n  }\n\n  public release(): void {\n    this.deps.forEach(releaseDep);\n    this.connected = false;\n  }\n}\n\nconst emptyMap = new Map<unknown, IDependency>();\n\nclass ObjectPropertyDependency implements IDependency {\n  // object property has only 1 dep, there's no need to create a map\n  // so use an empty map instead\n  deps = emptyMap;\n  observer?: IPropertyObserver;\n  connected = false;\n\n  dep?: IDependency;\n\n  constructor(\n    public owner: IDependencyAndStateObserver,\n    public parent: ObjectDependency,\n    public property: string,\n    public value: any,\n  ) {}\n\n  public collect(): void {\n    this.dep = undefined;\n    const { owner } = this;\n    const valueDep = getDependency(owner, this, this.value);\n    if(valueDep == null) {\n      return;\n    }\n    this.dep = valueDep;\n    valueDep.collect();\n  }\n\n  public observe(): void {\n    if(this.observer == null) {\n      this.observer = this\n        .owner\n        .observerLocator\n        .getObserver(this.parent.value, this.property);\n    }\n    this.observer.subscribe(objectPropDepContext, this);\n    const { dep } = this;\n    if(dep != null) {\n      dep.observe();\n    }\n    this.connected = true;\n  }\n\n  public release(): void {\n    const { observer } = this;\n    if(observer != null) {\n      observer.unsubscribe(objectPropDepContext, this);\n      this.observer = undefined;\n    }\n    const { dep } = this;\n    if(dep != null) {\n      dep.release();\n      this.dep = undefined;\n    }\n    this.connected = false;\n  }\n\n  public call(): void {\n    // when property change\n    // 1. release all sub-deps\n    this.release();\n    // 2. re-evaluate the value\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    this.value = this.parent.value[this.property];\n    // 3. re-collect deps\n    this.collect();\n    this.observe();\n    // 4. notify the owner\n    this.owner.handleChange(this);\n  }\n}\n\nabstract class BaseCollectionDependency implements ICollectionDependency {\n  owner?: IDependencyAndStateObserver;\n  parent?: IDependency | null;\n  value?: any[] | Map<any, any> | Set<any>;\n\n  deps: Map<string | number, IDependency> = new Map();\n  observer?: ICollectionObserver;\n  connected = false;\n\n  abstract subscribeContext: string;\n\n  public abstract collect(): void;\n\n  public abstract getObserver(): ICollectionObserver;\n\n  public observe(): void {\n    if(this.observer == null) {\n      this.observer = this.getObserver();\n    }\n    this.observer.subscribe(this.subscribeContext, this);\n    this.deps.forEach(observeDep);\n    this.connected = true;\n  }\n\n  public release(): void {\n    const { observer } = this;\n    if(observer != null) {\n      observer.unsubscribe(this.subscribeContext, this);\n      this.observer = undefined;\n    }\n    this.deps.forEach(releaseDep);\n    this.deps.clear();\n    this.connected = false;\n  }\n\n  // todo: more efficient dep recollection\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  public call(context: string, changeRecords: ICollectionObserverSplice[]): void {\n    // when array is mutated\n    // 1. release\n    this.release();\n    // 2. recollect\n    this.collect();\n    this.observe();\n    // 3. notify owner\n    this.owner?.handleChange(this as IDependency);\n  }\n}\n\nclass ArrayDependency extends BaseCollectionDependency implements IDependency {\n\n  subscribeContext = arrayDepContext;\n\n  constructor(\n    public owner: IDependencyAndStateObserver,\n    public parent: IDependency | null,\n    public value: any[],\n  ) {\n    super();\n  }\n\n  public getObserver(): ICollectionObserver {\n    return this\n      .owner\n      .observerLocator\n      .getArrayObserver(this.value);\n  }\n\n  public collect(): void {\n    const { owner } = this;\n    const { deps } = this;\n    for(let i = 0, arr = this.value, ii = arr.length; ii > i; ++i) {\n      const value = arr[i];\n      const dep = getDependency(owner, this, value);\n      // if an index is not observable\n      // just ignore\n      if(dep == null) {\n        return;\n      }\n      const existingDep = deps.get(i);\n      if(existingDep) {\n        existingDep.release();\n      }\n      deps.set(i, dep);\n      dep.collect();\n    }\n  }\n}\n\nclass MapDependency extends BaseCollectionDependency implements IDependency {\n\n  subscribeContext = mapDepContext;\n\n  constructor(\n    public owner: IDependencyAndStateObserver,\n    public parent: IDependency | null,\n    public value: Map<any, any>,\n  ) {\n    super();\n  }\n\n  public getObserver(): ICollectionObserver {\n    return this\n      .owner\n      .observerLocator\n      .getMapObserver(this.value);\n  }\n\n  public collect(): void {\n    const { owner } = this;\n    const { deps } = this;\n    this.value.forEach((value, key) => {\n      const dep = getDependency(owner, this, value);\n      if(dep == null) {\n        return;\n      }\n      const existingDep = deps.get(key);\n      if(existingDep) {\n        existingDep.release();\n      }\n      // incorrect to typings, but safe\n      deps.set(key, dep);\n      dep.collect();\n    });\n  }\n}\n\nclass SetDependency extends BaseCollectionDependency implements IDependency {\n\n  subscribeContext = setDepContext;\n\n  constructor(\n    public owner: IDependencyAndStateObserver,\n    public parent: IDependency | null,\n    public value: Set<any>,\n  ) {\n    super();\n  }\n\n  public getObserver(): ICollectionObserver {\n    return this\n      .owner\n      .observerLocator\n      .getSetObserver(this.value);\n  }\n\n  public collect(): void {\n    const { owner } = this;\n    const { deps } = this;\n    this.value.forEach(value => {\n      const dep = getDependency(owner, this, value);\n      if(dep == null) {\n        return;\n      }\n      const existingDep = deps.get(value);\n      if(existingDep) {\n        existingDep.release();\n      }\n      deps.set(value, dep);\n      dep.collect();\n    });\n  }\n}\n\nexport function getDependency(owner: IDependencyAndStateObserver, parent: IDependency | null, value: unknown): IDependency | null {\n  const valueType = typeof value;\n  if(\n    value == null\n    || valueType === 'boolean'\n    || valueType === 'number'\n    || valueType === 'string'\n    || valueType === 'symbol'\n    || valueType === 'bigint'\n    || typeof value === 'function'\n  ) {\n    return null;\n  }\n\n  if(Array.isArray(value)) {\n    return new ArrayDependency(owner, parent, value);\n  }\n\n  if(value instanceof Map) {\n    return new MapDependency(owner, parent, value);\n  }\n\n  if(value instanceof Set) {\n    return new SetDependency(owner, parent, value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  return new ObjectDependency(owner, parent, value as object);\n}\n","import { FrameworkConfiguration } from 'aurelia-framework';\nimport {\n  ObserverLocator,\n  Parser,\n  InternalPropertyObserver,\n} from 'aurelia-binding';\nimport {\n  ISelectStatePropertyDescriptor,\n  IProcessedSelectStateOptions,\n  SelectorCreator,\n} from './definitions';\nimport { DependencyAndStateObserver } from './dependency-and-state-observer';\nimport { DependencyExpression } from './dependency-expression';\n\nexport { DependencyAndStateObserver } from './dependency-and-state-observer';\nexport { SelectStateObservableComponent } from './select-state-observable-component';\nexport { IDependency } from './definitions';\n\nexport function configure(config: FrameworkConfiguration): void {\n  // need to run at post task to ensure we don't resolve everything too early\n  config.postTask(() => {\n    const { container } = config;\n    const observerLocator = container.get(ObserverLocator);\n    const parser = container.get(Parser);\n    // addAdapter is a hook from observer locator to deal with computed properties (getter/getter + setter)\n    observerLocator.addAdapter({\n      getObserver: (\n        obj, propertyName, descriptor: PropertyDescriptor & { get?: (() => unknown) & { selectStateOptions: unknown }},\n      ): InternalPropertyObserver | null => {\n        return createObserver(obj, propertyName, descriptor, parser, observerLocator);\n      },\n    });\n  });\n}\n\nexport function selectState<TClass, TState, TSelected, TDependencyObject>(\n  classConstructor: new (...args: any[]) => TClass,\n  selectorCreator: SelectorCreator<TState, TSelected, TDependencyObject>,\n  dependencies: Array<keyof TClass & string>,\n): PropertyDecorator {\n  // eslint-disable-next-line func-names, @typescript-eslint/ban-types\n  return function(_target: Object, propertyName: string, descriptor?: PropertyDescriptor) {\n    const innerPropertyName = `_${propertyName}`;\n    const callbackName = `${propertyName}Changed`;\n\n    // eslint-disable-next-line no-param-reassign\n    descriptor = descriptor ?? {};\n    // eslint-disable-next-line func-names\n    descriptor.get = function() {\n      const self = this as any;\n      return self[innerPropertyName];\n    };\n    // eslint-disable-next-line func-names\n    descriptor.set = function(newValue: TSelected) {\n      const self = this as any;\n      const oldValue = self[innerPropertyName] as TSelected | undefined;\n      if(newValue === oldValue) return;\n\n      // Add the inner property on the instance and make it nonenumerable.\n      self[innerPropertyName] = newValue;\n      Reflect.defineProperty(this, innerPropertyName, { enumerable: false });\n\n      if(self[callbackName] != null) {\n        self[callbackName](newValue, oldValue, propertyName);\n      }\n    };\n\n    (descriptor as ISelectStatePropertyDescriptor<TState, TSelected, TDependencyObject>).get.selectStateOptions = { selectorCreator, dependencies };\n    return descriptor;\n  } as PropertyDecorator;\n}\n\nexport function createObserver<TState, TSelected, TDependencyObject>(\n  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n  obj: any,\n  propertyName: string,\n  descriptor: PropertyDescriptor & { get?: (() => unknown) & { selectStateOptions: unknown } },\n  parser: Parser,\n  observerLocator: ObserverLocator,\n): DependencyAndStateObserver<TState, TSelected, TDependencyObject> | null {\n  const selectStateOptions = descriptor.get?.selectStateOptions;\n\n  if(selectStateOptions != null) {\n    return createDependencyAndStateObserver(\n      obj,\n      propertyName,\n            descriptor as ISelectStatePropertyDescriptor<TState, TSelected, TDependencyObject>,\n      parser,\n      observerLocator,\n    );\n  }\n  return null;\n}\n\nexport function createDependencyAndStateObserver<TState, TSelected, TDependencyObject>(\n  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n  obj: any,\n  propertyName: string,\n  descriptor: ISelectStatePropertyDescriptor<TState, TSelected, TDependencyObject>,\n  parser: Parser,\n  observerLocator: ObserverLocator,\n): DependencyAndStateObserver<TState, TSelected, TDependencyObject> {\n  const getterFn = descriptor.get!;\n  const { dependencies, selectorCreator } = getterFn.selectStateOptions;\n\n  let dependencyExpression: DependencyExpression;\n  if(!('dependencyExpression' in getterFn.selectStateOptions && getterFn.selectStateOptions.dependencyExpression instanceof DependencyExpression)) {\n    let i = dependencies.length;\n\n    const parsedDeps = Array(dependencies.length);\n    (getterFn.selectStateOptions as IProcessedSelectStateOptions<TState, TSelected, TDependencyObject>).parsedDependencies = parsedDeps;\n\n    while(i--) {\n      parsedDeps[i] = parser.parse(dependencies[i]);\n    }\n\n    dependencyExpression = new DependencyExpression(propertyName, parsedDeps);\n    (getterFn.selectStateOptions as IProcessedSelectStateOptions<TState, TSelected, TDependencyObject>).dependencyExpression = dependencyExpression;\n  } else {\n    dependencyExpression = getterFn.selectStateOptions.dependencyExpression;\n  }\n\n  return new DependencyAndStateObserver<TState, TSelected, TDependencyObject>(\n    obj,\n    dependencyExpression,\n    observerLocator,\n    descriptor,\n    {\n      dependencies,\n      selectorCreator,\n    },\n  );\n}\n","import { Parser, ObserverLocator, autoinject } from 'aurelia-framework';\nimport { createObserver } from '.';\nimport { DependencyAndStateObserver } from './dependency-and-state-observer';\n\n/**\n * needed as base component if you want to use the `@selectState` decorator without providing\n * the decorated property in the view\n */\n@autoinject()\nexport class SelectStateObservableComponent {\n  private observerList: Array<{ observer: DependencyAndStateObserver<unknown, unknown, unknown>; callable: () => void }> = [];\n\n  constructor(\n    private parser: Parser,\n    private observerLocator: ObserverLocator,\n  ) { }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/explicit-module-boundary-types\n  protected bind(_bindingContext: any, _overrideContext: any): void {\n    const ownKeys = Reflect.ownKeys(Object.getPrototypeOf(this));\n    for(const key of ownKeys) {\n      const descriptor = Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(this), key);\n\n      if(descriptor != null) {\n        const observer = createObserver(\n          this,\n          String(key),\n          descriptor as PropertyDescriptor & { get?: (() => unknown) & { selectStateOptions: unknown } },\n          this.parser,\n          this.observerLocator,\n        );\n\n        if(observer != null) {\n          const callable = (): void => { };\n          this.observerList.push({\n            observer,\n            callable,\n          });\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          observer.subscribe(this, callable);\n        }\n      }\n    }\n  }\n\n  protected unbind(): void {\n    for(const observerEntry of this.observerList) {\n      observerEntry.observer.unsubscribe(this, observerEntry.callable);\n    }\n  }\n}\n"],"names":[],"sourceRoot":""}