@glimmer/util

Variables

• assign
• beginTestSteps
• EMPTY_ARRAY
• EMPTY_NUMBER_ARRAY
• EMPTY_STRING_ARRAY
• endTestSteps
• LOCAL_LOGGER
• LOGGER
• logStep
• SERIALIZATION_FIRST_NODE_STRING
• verifySteps

Functions

• assertNever()
• clearElement()
• dict()
• emptyArray()
• entries()
• enumerate()
• intern()
• isDict()
• isEmptyArray()
• isIndexable()
• isSerializationFirstNode()
• keys()
• reverse()
• strip()
• values()
• zipArrays()
• zipTuples()

Classes

• Stack

  • current
  • isEmpty()
  • nth()
  • pop()
  • push()
  • size
  • snapshot()
  • toArray()

Type Aliases

• FIXME

variable assign

let assign: {
    <T extends {}, U>(target: T, source: U): T & U;
    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
    <T_2 extends {}, U_2, V_1, W>(
        target: T_2,
        source1: U_2,
        source2: V_1,
        source3: W
    ): T_2 & U_2 & V_1 & W;
    (target: object, ...sources: any[]): any;
};

variable beginTestSteps

let beginTestSteps: () => void;

variable EMPTY_ARRAY

const EMPTY_ARRAY: readonly unknown[];

variable EMPTY_NUMBER_ARRAY

const EMPTY_NUMBER_ARRAY: number[];

variable EMPTY_STRING_ARRAY

const EMPTY_STRING_ARRAY: string[];

variable endTestSteps

let endTestSteps: () => void;

variable LOCAL_LOGGER

const LOCAL_LOGGER: Console;

• This constant exists to make it easier to differentiate normal logs from errant console.logs. LOCAL_LOGGER should only be used inside a LOCAL_TRACE_LOGGING check.

  It does not alleviate the need to check LOCAL_TRACE_LOGGING, which is used for stripping.

variable LOGGER

const LOGGER: Console;

• This constant exists to make it easier to differentiate normal logs from errant console.logs. LOGGER can be used outside of LOCAL_TRACE_LOGGING checks, and is meant to be used in the rare situation where a console.* call is actually appropriate.

variable logStep

let logStep: (type: string, steps: unknown) => void;

variable SERIALIZATION_FIRST_NODE_STRING

const SERIALIZATION_FIRST_NODE_STRING: string;

variable verifySteps

let verifySteps: (
    type: string,
    steps: unknown[] | ((steps: unknown[]) => void),
    message?: string
) => void;

function assertNever

assertNever: (value: never, desc?: string) => never;

function clearElement

clearElement: (parent: SimpleElement) => void;

function dict

dict: <T = unknown>() => Dict<T>;

function emptyArray

emptyArray: <T>() => T[];

function entries

entries: <D extends object>(dict: D) => ObjectEntry<D>[];

function enumerate

enumerate: <T>(input: Iterable<T>) => IterableIterator<[number, T]>;

function intern

intern: (str: string) => string;

• Strongly hint runtimes to intern the provided string.

  When do I need to use this function?

  For the most part, never. Pre-mature optimization is bad, and often the runtime does exactly what you need it to, and more often the trade-off isn't worth it.

  Why?

  Runtimes store strings in at least 2 different representations: Ropes and Symbols (interned strings). The Rope provides a memory efficient data-structure for strings created from concatenation or some other string manipulation like splitting.

  Unfortunately checking equality of different ropes can be quite costly as runtimes must resort to clever string comparison algorithms. These algorithms typically cost in proportion to the length of the string. Luckily, this is where the Symbols (interned strings) shine. As Symbols are unique by their string content, equality checks can be done by pointer comparison.

  How do I know if my string is a rope or symbol?

  Typically (warning general sweeping statement, but truthy in runtimes at present) static strings created as part of the JS source are interned. Strings often used for comparisons can be interned at runtime if some criteria are met. One of these criteria can be the size of the entire rope. For example, in chrome 38 a rope longer then 12 characters will not intern, nor will segments of that rope.

  Some numbers: http://jsperf.com/eval-vs-keys/8

  Known Trick™

  {String} interned version of the provided string

function isDict

isDict: <T>(u: T) => u is any;

function isEmptyArray

isEmptyArray: (input: unknown[] | readonly unknown[]) => boolean;

• This function returns true if the input array is the special empty array sentinel, which is sometimes used for optimizations.

function isIndexable

isIndexable: <T>(u: T) => u is object & T;

function isSerializationFirstNode

isSerializationFirstNode: (node: SimpleNode) => boolean;

function keys

keys: <T extends object>(obj: T) => (keyof T)[];

function reverse

reverse: <T>(input: T[]) => IterableIterator<T>;

function strip

strip: (strings: TemplateStringsArray, ...args: unknown[]) => string;

function values

values: <T>(obj: { [s: string]: T }) => T[];

function zipArrays

zipArrays: <T>(
    left: T[],
    right: T[]
) => IterableIterator<
    | ['retain', number, T, T]
    | ['pop', number, T, undefined]
    | ['push', number, undefined, T]
>;

function zipTuples

zipTuples: <T extends readonly unknown[]>(
    left: T,
    right: T
) => IterableIterator<ZipEntry<T>>;

• Zip two tuples with the same type and number of elements.

type FIXME

type FIXME<T, S extends string> = (T & S) | T;