• Version 0.92.0
  • Published
  • 58.8 kB
  • 5 dependencies
  • MIT license


npm i @glimmer/reference
yarn add @glimmer/reference
pnpm add @glimmer/reference


Objects used to track values and their dirtiness in Glimmer



variable createDebugAliasRef

let createDebugAliasRef: (debugLabel: string, inner: Reference) => Reference;

    variable FALSE_REFERENCE

    const FALSE_REFERENCE: Reference<false>;

      variable NULL_REFERENCE

      const NULL_REFERENCE: Reference<any>;

        variable REFERENCE

        const REFERENCE: ReferenceSymbol;

          variable TRUE_REFERENCE

          const TRUE_REFERENCE: Reference<true>;

            variable UNDEFINED_REFERENCE

            const UNDEFINED_REFERENCE: Reference<any>;


              function childRefFor

              childRefFor: (_parentRef: Reference, path: string) => Reference;

                function childRefFromParts

                childRefFromParts: (root: Reference, parts: string[]) => Reference;

                  function createComputeRef

                  createComputeRef: <T = unknown>(
                  compute: () => T,
                  update?: Nullable<(value: T) => void>,
                  debugLabel?: false | string
                  ) => Reference<T>;

                    function createConstRef

                    createConstRef: <T>(value: T, debugLabel: false | string) => Reference<T>;

                      function createInvokableRef

                      createInvokableRef: (inner: Reference) => Reference;

                        function createIteratorItemRef

                        createIteratorItemRef: (_value: unknown) => Reference<unknown>;

                          function createIteratorRef

                          createIteratorRef: (
                          listRef: Reference,
                          key: string
                          ) => Reference<ArrayIterator | IteratorWrapper>;

                            function createPrimitiveRef

                            createPrimitiveRef: <T extends string | number | boolean | symbol>(
                            value: T
                            ) => Reference<T>;

                              function createReadOnlyRef

                              createReadOnlyRef: (ref: Reference) => Reference;

                                function createUnboundRef

                                createUnboundRef: <T>(value: T, debugLabel: false | string) => Reference<T>;

                                  function isConstRef

                                  isConstRef: (_ref: Reference) => boolean;

                                    function isInvokableRef

                                    isInvokableRef: (ref: Reference) => boolean;

                                      function isUpdatableRef

                                      isUpdatableRef: (_ref: Reference) => boolean;

                                        function updateRef

                                        updateRef: (_ref: Reference, value: unknown) => void;

                                          function valueForRef

                                          valueForRef: <T>(_ref: Reference<T>) => T;


                                            interface AbstractIterator

                                            interface AbstractIterator<T, U, V extends IterationItem<T, U>> {}

                                              method isEmpty

                                              isEmpty: () => boolean;

                                                method next

                                                next: () => Nullable<V>;

                                                  interface IterationItem

                                                  interface IterationItem<T, U> {}

                                                    property key

                                                    key: unknown;

                                                      property memo

                                                      memo: U;

                                                        property value

                                                        value: T;

                                                          interface IteratorDelegate

                                                          interface IteratorDelegate {}

                                                            method isEmpty

                                                            isEmpty: () => boolean;

                                                              method next

                                                              next: () => { value: unknown; memo: unknown } | null;

                                                                interface ReferenceEnvironment

                                                                interface ReferenceEnvironment {}

                                                                  method getProp

                                                                  getProp: (obj: unknown, path: string) => unknown;

                                                                    method setProp

                                                                    setProp: (obj: unknown, path: string, value: unknown) => unknown;

                                                                      Type Aliases

                                                                      type OpaqueIterationItem

                                                                      type OpaqueIterationItem = IterationItem<unknown, unknown>;

                                                                        type OpaqueIterator

                                                                        type OpaqueIterator = AbstractIterator<unknown, unknown, OpaqueIterationItem>;

                                                                          Package Files (1)

                                                                          Dependencies (5)

                                                                          Dev Dependencies (6)

                                                                          Peer Dependencies (0)

                                                                          No peer dependencies.


                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@glimmer/reference.

                                                                          • Markdown
                                                                          • HTML
                                                                            <a href="https://www.jsdocs.io/package/@glimmer/reference"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>