Options
All
  • Public
  • Public/Protected
  • All
Menu

Module util/map

Index

Interfaces

Functions

Functions

MappedArray

  • MappedArray<Element, MapTo>(options: { data: any; map: any }): TrackedArrayMap<Element, MapTo>

  • Map utility to use map with @use

    example
    class {
      @tracked data = [...];

      @use mapped = MappedArray({
        data: () => this.data,
        map: (datum) => transform(datum)
      })
    }

    Type parameters

    • Element = unknown

    • MapTo = unknown

    Parameters

    • options: { data: any; map: any }
      • data:function
        • data(): Element[]

        • Array of non-primitives to map over

          This can be class instances, plain objects, or anything supported by WeakMap's key

          Returns Element[]

      • map:function
        • map(element: Element): MapTo

        • How to transform each element from data, similar to if you were to use Array map yourself.

          This function will be called only when needed / on-demand / lazily.

          • if iterating over part of the data, map will only be called for the elements observed
          • if not iterating, map will only be called for the elements observed.

          Parameters

          • element: Element

          Returns MapTo

    Returns TrackedArrayMap<Element, MapTo>

map

  • map<Element, MapTo>(destroyable: object, options: { data: any; map: any }): MappedArray<MapTo>

  • Reactivily apply a map function to each element in an array, persisting map-results for each object, based on identity.

    This is useful when you have a large collection of items that need to be transformed into a different shape (adding/removing/modifying data/properties) and you want the transform to be efficient when iterating over that data.

    A common use case where this map resource provides benefits over is

    class MyClass {\
      @cached
      get wrappedRecords() {
        return this.records.map(record => new SomeWrapper(record));
      }
    }

    Even though the above is @cached, if any tracked data accessed during the evaluation of wrappedRecords changes, the entire array.map will re-run, often doing duplicate work for every unchanged item in the array.

    example
     import { map } from 'ember-resources/utils/map';

     class MyClass {
       wrappedRecords = map(this, {
         data: () => this.records,
         map: (record) => new SomeWrapper(record),
       }),
     }

    Type parameters

    • Element = unknown

    • MapTo = unknown

    Parameters

    • destroyable: object
    • options: { data: any; map: any }
      • data:function
        • data(): Element[]

        • Array of non-primitives to map over

          This can be class instances, plain objects, or anything supported by WeakMap's key

          Returns Element[]

      • map:function
        • map(element: Element): MapTo

        • How to transform each element from data, similar to if you were to use Array map yourself.

          This function will be called only when needed / on-demand / lazily.

          • if iterating over part of the data, map will only be called for the elements observed
          • if not iterating, map will only be called for the elements observed.

          Parameters

          • element: Element

          Returns MapTo

    Returns MappedArray<MapTo>

    an object that behaves like an array. This shouldn't be modified directly. Instead, you can freely modify the data returned by the data function, which should be tracked in order to benefit from this abstraction.

Generated using TypeDoc