• Version 0.84.3
  • Published
  • 245 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<unknown>;

      variable NULL_REFERENCE

      const NULL_REFERENCE: Reference<unknown>;

        variable REFERENCE

        const REFERENCE: Symbol;

          variable TRUE_REFERENCE

          const TRUE_REFERENCE: Reference<unknown>;

            variable UNDEFINED_REFERENCE

            const UNDEFINED_REFERENCE: Reference<unknown>;


              function childRefFor

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

                function childRefFromParts

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

                  function createComputeRef

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

                    function createConstRef

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

                      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: (value: unknown) => Reference;

                              function createReadOnlyRef

                              createReadOnlyRef: (ref: Reference) => Reference;

                                function createUnboundRef

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

                                  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: () => Option<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 Reference

                                                                interface Reference<_T = unknown> {}

                                                                  property [REFERENCE]

                                                                  [REFERENCE]: ReferenceType;

                                                                    property children

                                                                    children: null | Map<string | Reference, Reference>;

                                                                      property debugLabel

                                                                      debugLabel?: string;

                                                                        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 (3)

                                                                                  Dependencies (5)

                                                                                  Dev Dependencies (0)

                                                                                  No dev dependencies.

                                                                                  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>