Class FeatureLayerCompat

constructor

• new FeatureLayerCompat(options: FeatureLayerCompatOptions): FeatureLayerCompat

  Parameters

  • options: FeatureLayerCompatOptions

  Returns FeatureLayerCompat

definitionExpression

ReadonlyeventBus

Readonlyfields

fullExtent

ReadonlygeometryType

id

labelingInfo

labelsVisible

ReadonlylayerId

legendEnabled

listMode

loaded

loadStatus

maxScale

metadata

minScale

ReadonlyobjectIdField

opacity

outFields

popupTemplate

renderer

ReadonlyserviceId

Readonlysource

timeExtent

title

Readonlyurl

visible

featureEffect

• get featureEffect(): unknown

  Returns unknown

• set featureEffect(value: unknown): void

  Parameters

  • value: unknown

  Returns void

addAttachment

• addAttachment(
      options: FeatureLayerAddAttachmentOptions,
  ): Promise<HonuaAddAttachmentResponse>

  Parameters

  • options: FeatureLayerAddAttachmentOptions

  Returns Promise<HonuaAddAttachmentResponse>

applyEdits

• applyEdits(options: FeatureLayerEditsOptions): Promise<HonuaApplyEditsResponse>

  Parameters

  • options: FeatureLayerEditsOptions

  Returns Promise<HonuaApplyEditsResponse>

applyToFeatures

• applyToFeatures(
      features: readonly { attributes?: Record<string, unknown> }[],
      change: Record<string, unknown>,
  ): Promise<
      {
          applied: FeatureEdit[];
          rejected: { feature: FeatureEdit; reason: string }[];
      },
  >

  Applies one attribute change to each feature through applyEdits. A named edit error rejects that feature only.

  Parameters

  • features: readonly { attributes?: Record<string, unknown> }[]
  • change: Record<string, unknown>

  Returns Promise<
      {
          applied: FeatureEdit[];
          rejected: { feature: FeatureEdit; reason: string }[];
      },
  >

createQuery

• createQuery(): FeatureLayerCreateQueryResult

  Returns FeatureLayerCreateQueryResult

deleteAttachments

• deleteAttachments(
      options: FeatureLayerDeleteAttachmentsOptions,
  ): Promise<HonuaDeleteAttachmentsResponse>

  Parameters

  • options: FeatureLayerDeleteAttachmentsOptions

  Returns Promise<HonuaDeleteAttachmentsResponse>

destroy

• destroy(): void

  Returns void

getField

• getField(fieldName: string): HonuaFieldInfo | undefined

  Parameters

  • fieldName: string

  Returns HonuaFieldInfo | undefined

hasField

• hasField(fieldName: string): boolean

  Parameters

  • fieldName: string

  Returns boolean

listAttachments

• listAttachments(
      options: FeatureLayerListAttachmentsOptions,
  ): Promise<HonuaAttachmentListResponse>

  Parameters

  • options: FeatureLayerListAttachmentsOptions

  Returns Promise<HonuaAttachmentListResponse>

listFields

• listFields(): readonly HonuaFieldInfo[]

  Returns readonly HonuaFieldInfo[]

load

• load(): Promise<FeatureLayerCompat>

  Returns Promise<FeatureLayerCompat>

on

• on(
      eventName: string,
      listener: (event: unknown) => void,
  ): FeatureLayerHandleCompat

  Parameters

  • eventName: string
  • listener: (event: unknown) => void

  Returns FeatureLayerHandleCompat

queryAttachments

• queryAttachments(
      options?: FeatureLayerQueryAttachmentsOptions,
  ): Promise<HonuaQueryAttachmentsResponse>

  Parameters

  • options: FeatureLayerQueryAttachmentsOptions = {}

  Returns Promise<HonuaQueryAttachmentsResponse>

queryExtent

• queryExtent(
      options?: FeatureLayerQueryCountOptions,
  ): Promise<FeatureLayerQueryExtentResult>

  Parameters

  • options: FeatureLayerQueryCountOptions = {}

  Returns Promise<FeatureLayerQueryExtentResult>

queryFeatureCount

• queryFeatureCount(options?: FeatureLayerQueryCountOptions): Promise<number>

  Parameters

  • options: FeatureLayerQueryCountOptions = {}

  Returns Promise<number>

queryFeatures

• queryFeatures(options?: FeatureLayerQueryOptions): Promise<HonuaQueryResponse>

  Parameters

  • options: FeatureLayerQueryOptions = {}

  Returns Promise<HonuaQueryResponse>

queryFeaturesAll

• queryFeaturesAll(options?: FeatureLayerQueryAllOptions): Promise<HonuaFeature[]>

  Parameters

  • options: FeatureLayerQueryAllOptions = {}

  Returns Promise<HonuaFeature[]>

queryFeaturesStream

• queryFeaturesStream(
      options?: FeatureLayerQueryAllOptions,
  ): AsyncGenerator<HonuaFeature[], void, undefined>

  Parameters

  • options: FeatureLayerQueryAllOptions = {}

  Returns AsyncGenerator<HonuaFeature[], void, undefined>

queryObjectIds

• queryObjectIds(options?: FeatureLayerQueryCountOptions): Promise<number[]>

  Parameters

  • options: FeatureLayerQueryCountOptions = {}

  Returns Promise<number[]>

queryRelatedFeatures

• queryRelatedFeatures(
      options: FeatureLayerQueryRelatedFeaturesOptions,
  ): Promise<HonuaRelatedRecordsResponse>

  Parameters

  • options: FeatureLayerQueryRelatedFeaturesOptions

  Returns Promise<HonuaRelatedRecordsResponse>

queryRelatedRecords

• queryRelatedRecords(
      options: FeatureLayerQueryRelatedFeaturesOptions,
  ): Promise<HonuaRelatedRecordsResponse>

  Parameters

  • options: FeatureLayerQueryRelatedFeaturesOptions

  Returns Promise<HonuaRelatedRecordsResponse>

refresh

• refresh(): void

  Returns void

setDefinitionExpression

• setDefinitionExpression(definitionExpression: string | undefined): void

  Parameters

  • definitionExpression: string | undefined

  Returns void

setLabelingInfo

• setLabelingInfo(labelingInfo: readonly unknown[]): void

  Parameters

  • labelingInfo: readonly unknown[]

  Returns void

setLabelsVisible

• setLabelsVisible(labelsVisible: boolean): void

  Parameters

  • labelsVisible: boolean

  Returns void

setLegendEnabled

• setLegendEnabled(legendEnabled: boolean): void

  Parameters

  • legendEnabled: boolean

  Returns void

setOpacity

• setOpacity(opacity: number): void

  Parameters

  • opacity: number

  Returns void

setOutFields

• setOutFields(outFields: string | readonly string[] | undefined): void

  Parameters

  • outFields: string | readonly string[] | undefined

  Returns void

setPopupTemplate

• setPopupTemplate(popupTemplate: unknown): void

  Parameters

  • popupTemplate: unknown

  Returns void

setRenderer

• setRenderer(renderer: unknown): void

  Parameters

  • renderer: unknown

  Returns void

setScaleRange

• setScaleRange(minScale: number | undefined, maxScale: number | undefined): void

  Parameters

  • minScale: number | undefined
  • maxScale: number | undefined

  Returns void

setTimeExtent

• setTimeExtent(extent: { end: Date; start: Date } | undefined): void

  Parameters

  • extent: { end: Date; start: Date } | undefined

  Returns void

setVisibility

• setVisibility(visible: boolean): void

  Parameters

  • visible: boolean

  Returns void

symbolForFeature

• symbolForFeature(feature: unknown): unknown

  Symbol the view should paint for one feature. A feature's own symbol wins. Otherwise the renderer supplies it, and an excluded feature effect replaces the color.

  Parameters

  • feature: unknown

  Returns unknown

updateAttachment

• updateAttachment(
      options: FeatureLayerUpdateAttachmentOptions,
  ): Promise<HonuaUpdateAttachmentResponse>

  Parameters

  • options: FeatureLayerUpdateAttachmentOptions

  Returns Promise<HonuaUpdateAttachmentResponse>

watch

• watch(
      propertyName: "labelsVisible" | "visible" | "legendEnabled" | "loaded",
      listener: (value: boolean) => void,
  ): FeatureLayerHandleCompat

  Parameters

  • propertyName: "labelsVisible" | "visible" | "legendEnabled" | "loaded"
  • listener: (value: boolean) => void

  Returns FeatureLayerHandleCompat

• watch(
      propertyName: "opacity" | "minScale" | "maxScale",
      listener: (value: number) => void,
  ): FeatureLayerHandleCompat

  Parameters

  • propertyName: "opacity" | "minScale" | "maxScale"
  • listener: (value: number) => void

  Returns FeatureLayerHandleCompat

• watch(
      propertyName: "loadStatus",
      listener: (value: FeatureLayerLoadStatusCompat) => void,
  ): FeatureLayerHandleCompat

  Parameters

  • propertyName: "loadStatus"
  • listener: (value: FeatureLayerLoadStatusCompat) => void

  Returns FeatureLayerHandleCompat

• watch(
      propertyName: string,
      listener: (value: unknown) => void,
  ): FeatureLayerHandleCompat

  Parameters

  • propertyName: string
  • listener: (value: unknown) => void

  Returns FeatureLayerHandleCompat

when

• when(
      callback?: (layer: FeatureLayerCompat) => void,
  ): Promise<FeatureLayerCompat>

  Parameters

  • Optionalcallback: (layer: FeatureLayerCompat) => void

  Returns Promise<FeatureLayerCompat>