Class MapLayers

ReadonlyclassName

Readonlyhandle

Optional Readonlyid

events

• get events(): string[]

  Returns string[]

valid

• get valid(): boolean

  False after destroy, and after the id was dropped.

  Returns boolean

addEventListener

• addEventListener(
      eventNames: string,
      callback: (data: EventData) => void,
      thisArg?: any,
      ...rest: any[],
  ): void

  A facade event takes its native subscription here, on the first handler.

  Parameters

  • eventNames: string
  • callback: (data: EventData) => void
  • OptionalthisArg: any
  • ...rest: any[]

  Returns void

apply

• apply(values: Partial<{ [P in WritablePath<C>]: WriteAt<C, P> }>): this

  Several properties in ONE JNI/JSI crossing via setAll. Object values (handles, inline specs) cannot be JSON and go one by one, as does everything on an SDK without setAll.

  Parameters

  • values: Partial<{ [P in WritablePath<C>]: WriteAt<C, P> }>

  Returns this

call

• call<M extends MethodName<"massif::Layers">>(
      method: M,
      ...args: {
          add: { args: [layer: Handle<any>]; result: void };
          clear: { args: []; result: void };
          get: {
              args: [index: number];
              result: Handle<"massif::Layer">;
              resultClass: "massif::Layer";
          };
          insert: { args: [index: number, layer: Handle<any>]; result: void };
          remove: { args: [layer: Handle<any>]; result: boolean };
          set: { args: [index: number, layer: Handle<any>]; result: void };
      }[M] extends { args: A }
          ? A extends unknown[] ? A<A> : never
          : never,
  ): CallResult<"massif::Layers", M>

  The path may traverse object properties (layer.call('tileDecoder.setStyleParameter', ...)). An object result is a MassifObject the CALLER OWNS - destroy() it, or it stays registered.

  Type Parameters

  • M extends MethodName<"massif::Layers">

  Parameters

  • method: M
  • ...args: {
        add: { args: [layer: Handle<any>]; result: void };
        clear: { args: []; result: void };
        get: {
            args: [index: number];
            result: Handle<"massif::Layer">;
            resultClass: "massif::Layer";
        };
        insert: { args: [index: number, layer: Handle<any>]; result: void };
        remove: { args: [layer: Handle<any>]; result: boolean };
        set: { args: [index: number, layer: Handle<any>]; result: void };
    }[M] extends { args: A }
        ? A extends unknown[] ? A<A> : never
        : never

  Returns CallResult<"massif::Layers", M>

callAsync

• callAsync<
      M extends MethodName<"massif::Layers">,
      R = CallResult<"massif::Layers", M>,
  >(
      method: M,
      args: {
          add: { args: [layer: Handle<any>]; result: void };
          clear: { args: []; result: void };
          get: {
              args: [index: number];
              result: Handle<"massif::Layer">;
              resultClass: "massif::Layer";
          };
          insert: { args: [index: number, layer: Handle<any>]; result: void };
          remove: { args: [layer: Handle<any>]; result: boolean };
          set: { args: [index: number, layer: Handle<any>]; result: void };
      }[M] extends { args: A }
          ? A extends unknown[] ? A<A> : never
          : never,
      extract?: (result: MassifObject<ResultClass<"massif::Layers", M>>) => R,
  ): CancellablePromise<R>

  call on a worker. extract runs INSIDE the delivery, the only time an object result is alive, e.g. (tile) => tile.getData('data'). Scalars and flat arrays need no extract.

  Type Parameters

  • M extends MethodName<"massif::Layers">
  • R = CallResult<"massif::Layers", M>

  Parameters

  • method: M
  • args: {
        add: { args: [layer: Handle<any>]; result: void };
        clear: { args: []; result: void };
        get: {
            args: [index: number];
            result: Handle<"massif::Layer">;
            resultClass: "massif::Layer";
        };
        insert: { args: [index: number, layer: Handle<any>]; result: void };
        remove: { args: [layer: Handle<any>]; result: boolean };
        set: { args: [index: number, layer: Handle<any>]; result: void };
    }[M] extends { args: A }
        ? A extends unknown[] ? A<A> : never
        : never
  • Optionalextract: (result: MassifObject<ResultClass<"massif::Layers", M>>) => R

  Returns CancellablePromise<R>

cancelCalls

• cancelCalls(): number

  Returns number

child

• child<P extends never>(path: P): MassifObject<ClassAtPath<"massif::Layers", P>>

  The object behind an object property, OWNED by the caller (destroy() it); null when empty. Unlike group it hands the object over, e.g. to share a source between layers.

  Type Parameters

  • P extends never

  Parameters

  • path: P

  Returns MassifObject<ClassAtPath<"massif::Layers", P>>

collect

• collect<R>(map: (element: MassifObject<any>, index: number) => R): R[]

  Defaults cover a search result; a route's instructions are collect(fn, { countPath: 'instructionCount', method: 'getInstruction' }).

  Type Parameters

  • R

  Parameters

  • map: (element: MassifObject<any>, index: number) => R

  Returns R[]

• collect<M extends MethodName<"massif::Layers">, R>(
      map: (
          element: MassifObject<ResultClass<"massif::Layers", M>>,
          index: number,
      ) => R,
      options: { countPath: string; method: M },
  ): R[]

  Defaults cover a search result; a route's instructions are collect(fn, { countPath: 'instructionCount', method: 'getInstruction' }).

  Type Parameters

  • M extends MethodName<"massif::Layers">
  • R

  Parameters

  • map: (element: MassifObject<ResultClass<"massif::Layers", M>>, index: number) => R
  • options: { countPath: string; method: M }

  Returns R[]

destroy

• destroy(): boolean

  Subscriptions and pending async calls die with it, so no handler runs against a freed object.

  Returns boolean

eventOptions

• eventOptions(options: SubscribeOptions): this

  Defaults for every later subscription on this object.

  Parameters

  • options: SubscribeOptions

  Returns this

get

• get<P extends "count">(path: P): ValueAt<"massif::Layers", P>

  The path may walk objects (fogOptions.rangeStart), structs (clickInfo.clickType) and free-form data (properties.name). Enums come back as names, positions as [lon, lat], structs as JSON.

  Type Parameters

  • P extends "count"

  Parameters

  • path: P

  Returns ValueAt<"massif::Layers", P>

getData

• getData(path?: string): ArrayBuffer

  An empty path means the handle IS the blob.

  Parameters

  • Optionalpath: string

  Returns ArrayBuffer

getDoubles

• getDoubles(): number[]

  Returns number[]

getPos

• getPos<P extends never>(
      path: P,
      projection?: ProjectionName,
  ): P extends "count"
      ? Extract<{ count: number }[P<P>], Position | Bounds>
      : Position | Bounds

  WGS84 [lng, lat] unless a projection is named here or on the subscription. An object whose source projection is unknown is left unconverted: a wrong guess is worse than an unconverted number.

  Type Parameters

  • P extends never

  Parameters

  • path: P
  • Optionalprojection: ProjectionName

  Returns P extends "count"
      ? Extract<{ count: number }[P<P>], Position | Bounds>
      : Position | Bounds

• getPos(path: string & {}, projection?: ProjectionName): Position | Bounds

  A path the tables do not carry - the concrete class is more derived than the declared one.

  Parameters

  • path: string & {}
  • Optionalprojection: ProjectionName

  Returns Position | Bounds

group

• group<P extends never>(path: P): PropertyGroup<ClassAtPath<"massif::Layers", P>>

  Type Parameters

  • P extends never

  Parameters

  • path: P

  Returns PropertyGroup<ClassAtPath<"massif::Layers", P>>

is

• is(className: ClassName): boolean

  instanceof by class name, e.g. layer.is('massif::RasterTileLayer').

  Parameters

  • className: ClassName

  Returns boolean

json

• json(path?: string): Json

  Escape hatch for paths the tables cannot type: free-form feature properties, a more derived class.

  Parameters

  • Optionalpath: string

  Returns Json

off

• off<E extends never>(event: E, callback?: any, thisArg?: any): void

  Removes the listener(s) for the specified event name.

  Type Parameters

  • E extends never

  Parameters

  • event: E
  • Optionalcallback: any

    An optional specific event listener to remove (if omitted, all event listeners by this name will be removed).

  • OptionalthisArg: any

    An optional parameter which, when set, will be used to refine search of the correct event listener to be removed.

  Returns void

on

• on<E extends never>(
      event: E,
      callback: (data: MassifEventData<"massif::Layers", E>) => void,
      thisArg?: any,
  ): void

  Deliberately NOT widened to string so event-name typos fail; addEventListener takes any name.

  Type Parameters

  • E extends never

  Parameters

  • event: E
  • callback: (data: MassifEventData<"massif::Layers", E>) => void
  • OptionalthisArg: any

  Returns void

once

• once<E extends never>(
      event: E,
      callback: (data: MassifEventData<"massif::Layers", E>) => void,
      thisArg?: any,
  ): void

  Adds a listener for the specified event name, which, once fired, will remove itself.

  Type Parameters

  • E extends never

  Parameters

  • event: E
  • callback: (data: MassifEventData<"massif::Layers", E>) => void

    The event listener to add. Will be called when an event of the given name is raised.

  • OptionalthisArg: any

    An optional parameter which, when set, will be bound as the this context when the callback is called. Falsy values will be not be bound.

  Returns void

removeEventListener

• removeEventListener(eventNames: string, callback?: any, thisArg?: any): void

  Removes listener(s) for the specified event name.

  Parameters

  • eventNames: string
  • Optionalcallback: any

    An optional parameter pointing to a specific listener. If not defined, all listeners for the event names will be removed.

  • OptionalthisArg: any

    An optional parameter which when set will be used to refine search of the correct callback which will be removed as event listener.

  Returns void

set

• set<P extends never>(path: P, value: WriteAt<"massif::Layers", P>): this

  An enum takes its constant name, a position an array.

  Type Parameters

  • P extends never

  Parameters

  • path: P
  • value: WriteAt<"massif::Layers", P>

  Returns this

subscribe

• subscribe<E extends never>(
      event: E,
      handler: (data: MassifEventData<"massif::Layers", E>) => void,
      options?: SubscribeOptions,
  ): Subscription

  For a handler needing its own projection or delivery; on covers most cases.

  Type Parameters

  • E extends never

  Parameters

  • event: E
  • handler: (data: MassifEventData<"massif::Layers", E>) => void
  • Optionaloptions: SubscribeOptions

  Returns Subscription

toString

• toString(): string

  Returns a string representation of an object.

  Returns string

trySet

• trySet<P extends never>(path: P, value: WriteAt<"massif::Layers", P>): number

  The same without throwing, for a path that may legitimately not be there.

  Type Parameters

  • P extends never

  Parameters

  • path: P
  • value: WriteAt<"massif::Layers", P>

  Returns number