Class Watch

constructor

• new Watch(watchDisplay: string, subject: Subject, grid?: HGrid): Watch

• Constructs a new watch.

  Please note, all watches must be closed when no longer used.

  Parameters

  • watchDisplay: string

    A client side display name for the watch.
  • subject: Subject

    The watch will observe this subject.
  • grid: HGrid = ...

    An empty grid to use for the watch.

  Returns Watch

Readonlygrid

display

• get display(): string

• console.log(watch.display)
  Copy

  Returns string

  The display name of the watch.

errorRefs

• get errorRefs(): HRef[]

• Returns HRef[]

  the ids as refs of the records that in error and can't be watched on the server.

errors

• get errors(): string[]

• Returns string[]

  The ids of the records that are in error and can't be watched on the server.

pollRate

• get pollRate(): number

• Returns the poll rate in seconds.

  const pollRate = watch.pollRate
  Copy

  Returns number

  The poll rate for this watch.
• set pollRate(pollRate: number): void

• Attempt to set a new poll rate in seconds for the watch.

  Please note, this value may be ignored.

  // Set the poll rate to 10 seconds.
  watch.pollRate = 10
  Copy

  Parameters

  • pollRate: number

    The poll rate.

  Returns void

Staticwatches

• get watches(): Watch[]

• Returns a list of watches.

  hs.Watch.watches.forEach((watch: Watch): void => {
    console.log(`We have watch: ${watch.display}`)
  })
  Copy

  Returns Watch[]

  A list of all open watches.

add

• add(ids: Ids): Promise<void>

• Add records to watch.

  await watch.add('@someid')
  Copy

  Parameters

  • ids: Ids

    The ids to add.

  Returns Promise<void>

addToGrid

• addToGrid(dicts: HDict[]): void

• Add the dicts to the watch's grid.

  This method can be overridden to track grid mutations.

  Parameters

  • dicts: HDict[]

    The dicts to add to the grid.

  Returns void

changed

• changed(
      __namedParameters: {
          callback: WatchEventCallback;
          condition?: string;
          interests?: string[];
      },
  ): WatchEventCallback

• Builds a changed callback handler based upon the parameters.

  Please note, the returned callback should be used to unregister the callback handler from the watch.

  // Add event handlers. We're only interested in 'curVal' changes.
  watch.changed({
    interests: ['curVal'],
    callback: (event) => console.log(event)
  })
  
  ...
  
  // Add event handlers. We're only interested in changes to curVal when it's above
  // a certain value.
  watch.changed({
  	interests: ['curVal'],
  	condition: 'curVal > 50°F',
  	callback: event => console.log(event),
  })
  Copy

  Parameters

  • __namedParameters: { callback: WatchEventCallback; condition?: string; interests?: string[] }

  Returns WatchEventCallback

  The built callback handler.

  Throws

  An error if the haystack filter is invalid.

clear

• clear(): Promise<void>

• Clear all watched items from the watch.

  Please note, this will not close the watch or remove any associated method handlers.

  await watch.clear()
  Copy

  Returns Promise<void>

clearCallbacks

• clearCallbacks(): this

• Clear all callback event handlers on the watch.

  // Clear all callbacks from the watch.
  watch.clearCallbacks()
  Copy

  Returns this

  The emitter instance.

clearGrid

• clearGrid(): void

• Empty the grid.

  This method can be overridden to track grid mutations.

  Returns void

close

• close(): Promise<void>

• Close the watch.

  After this has been called, the underlying watch will be destroyed and will be no longer active. The watch is effectively 'dead' after this has been called.

  // We must always close a watch once we've finished using it.
  await watch.close()
  Copy

  Returns Promise<void>

fire

• fire(event: WatchEvent): this

• Fire an event callback.

  Parameters

  • event: WatchEvent

    The event object.

  Returns this

  The emitter instance.

getCallbacks

• getCallbacks(eventType?: WatchEventType): WatchEventCallback[]

• Return the callbacks for the event type or all callbacks if the event type is not specified.

  const anArrayOfCallbacks = watch.getCallbacks()
  Copy

  Parameters

  • OptionaleventType: WatchEventType

    Optional event type.

  Returns WatchEventCallback[]

  The callbacks.

hasCallbacks

• hasCallbacks(eventType?: WatchEventType): boolean

• Return true if there are callback handlers for the specified event type.

  If there event type is not specified then check to see if there are any callback handlers.

  if (watch.hasCallbacks()) {
    // Do something...
  }
  Copy

  Parameters

  • OptionaleventType: WatchEventType

  Returns boolean

  True if there are callbacks.

hasErrorForId

• hasErrorForId(id: string | HRef | HDict): boolean

• Return true if the id or the record is currently in error.

  Parameters

  • id: string | HRef | HDict

    The id or record to test.

  Returns boolean

  True if the id is in error.

hasErrors

• hasErrors(): boolean

• Returns boolean

  True if the watch has errors.

inspect

• inspect(): this

• Dump the watch to the local console output.

  watch.inspect()
  Copy

  Returns this

  The value instance.

inspectSubject

• inspectSubject(): this

• Dump the watch's subject to the local console output.

  watch.inspectSubject()
  Copy

  Returns this

  The value instance.

isClosed

• isClosed(): boolean

• Returns true if the watch is closed.

  if (watch.isClosed()) {
    // Do something
  }
  Copy

  Returns boolean

  True if the watch is closed. A closed watch can no longer be used.

off

• off(eventType: WatchEventType, callback: WatchEventCallback): this

• Remove an event handler from a watch.

  watch.off(WatchEventType.Changed, cb)
  Copy

  Parameters

  • eventType: WatchEventType

    event type to remove.
  • callback: WatchEventCallback

    callback to remove.

  Returns this

  The emitter instance.

on

• on(eventType: WatchEventType, callback: WatchEventCallback): this

• Add an event handler for the specified event type.

  This is used to listen for watch events.

  watch.on(WatchEventType.Changed, (event: WatchEvent, emitter: WatchEventEmitter): void {
   // Do something with the event!
  })
  Copy

  Parameters

  • eventType: WatchEventType

    The event type to add the event for.
  • callback: WatchEventCallback

    The callback handler.

  Returns this

  The emitter instance.

  Throws

  An error if the watch is already closed.

poll

• poll(): Promise<void>

• Request a watch poll.

  Please note, polls are normally handled automatically so manually calling this is not normally required.

  Returns Promise<void>

refresh

• refresh(): Promise<void>

• Completely refresh the watch.

  await watch.refresh()
  Copy

  Returns Promise<void>

remove

• remove(ids: Ids): Promise<void>

• Remove records to watch.

  This is called to stop watching records.

  await watch.remove('@someid')
  Copy

  Parameters

  • ids: Ids

    The ids to remove.

  Returns Promise<void>

removeFromGrid

• removeFromGrid(filter: string): void

• Called to remove dicts from the watch's grid.

  This method can be overridden to track grid mutations.

  Parameters

  • filter: string

    The filter to remove items by.

  Returns void

toString

• toString(): string

• Returns string

  A string representation of a watch.

updateGrid

• updateGrid(
      __namedParameters: {
          events: { [prop: string]: WatchChanged };
          idsToGridIndexes: { [prop: string]: number };
      },
  ): void

• Update the grid with the new events information.

  Parameters

  • __namedParameters: {
        events: { [prop: string]: WatchChanged };
        idsToGridIndexes: { [prop: string]: number };
    }

  Returns void

Staticclose

• close(subject: Subject): Promise<void>

• Close all watches for the given subject.

  Please note, this method doesn't normally need to be called and is designed to be used internally. If you want to close a watch then please just call Watch.#close() instead.

  Parameters

  • subject: Subject

    The subject to close watches for.

  Returns Promise<void>

StaticinspectAll

• inspectAll(): void

• Inspect all the watches available.

  hs.Watch.inspectAll()
  Copy

  Returns void

Staticopen

• open(
      __namedParameters: {
          display: string;
          grid?: HGrid;
          ids: Ids;
          subject: Subject;
      },
  ): Promise<Watch>

• Return a new opened watch.

  Please note, all watches must be closed when no longer used.

  Parameters

  • __namedParameters: { display: string; grid?: HGrid; ids: Ids; subject: Subject }

  Returns Promise<Watch>

  An opened watch.

StaticupdateGrid

• updateGrid(
      idsToGridIndexes: { [prop: string]: number },
      grid: HGrid,
      events: { [prop: string]: WatchChanged },
  ): void

• Update the grid with the new events.

  Parameters

  • idsToGridIndexes: { [prop: string]: number }

    A cache of ids to dict indexes in the grid.
  • grid: HGrid

    The grid to update.
  • events: { [prop: string]: WatchChanged }

    The events to update the grid with.

  Returns void