@metreeca/keep
    Preparing search index...

    A node of a flake.

    The common base of every node: the root, each Branch, and each transform stage. A node carries the path locating it and the range it resolves to. Model- and query-mode flakes add the retrieval requested at the node; query-mode flakes also add its transform stages and its constraint, ordering, and pagination slots.

    type Flake = {
        path: readonly Identifier[];
        pipe: readonly Transform[];
        range: Range;
        drain?: Drain;
        transforms?: Transforms;
        entries?: Entries;
        lt?: Literal;
        gt?: Literal;
        lte?: Literal;
        gte?: Literal;
        like?: string;
        any?: Options;
        all?: Options;
        focus?: Options;
        order?: number;
        offset?: number;
        limit?: number;
    }
    Index

    Properties

    path: readonly Identifier[]

    The address of this node: the Property names walked from the root. Empty at the root.

    pipe: readonly Transform[]

    The transforms applied at this node. Empty except on a transform stage.

    range: Range

    The effective value Range this node resolves to against the flake's driving shape.

    The type and cardinality the node's path and pipe resolve to, composed across the steps from the root. A single-valued property under a multi-valued ancestor thus carries the multi-valued cardinality. On the root, the range envelopes the driving shape. On a Branch, it is the effective range of the entry; Id / Type markers resolve to the IRI range. On a transform stage, it is the output of the transform. Consumers read it directly, with no need to resolve it again through blue's effective.

    drain?: Drain

    The retrieval requested at this node, in a model- or query-mode flake.

    On the root, the drain holds the whole retrieval. On a Branch, it holds the query requested for the property; a requested Id / Type marker takes the atomic form. A projected node, including a transform stage, also carries the binding alias. A query root carries one when an empty-path binding (qest §5.8.1) projects the member itself: its drain remains the projection over the collection, and the properties the binding requests of the member appear among its entries. Absent where nothing is requested, as on a branch or marker present only to carry the constraints the query states for it.

    transforms?: Transforms

    The transform stages applied to this node, keyed by the Transform each applies.

    entries?: Entries

    This node's property branches (see Entries).

    Absent where the node has none: scalar and localised ranges, Id / Type markers, and transform stages. In a shape-mode flake, references other than captive ones carry none either. In a model-mode flake, properties retrieved as atomics carry none, and neither do multi-valued properties, whose drain holds the nested retrieval. In a query-mode flake, the root holds a branch for every path the query addresses, including the properties an empty-path binding requests of the member through its template.

    lt?: Literal

    Strict upper bound constraint (< operator).

    gt?: Literal

    Strict lower bound constraint (> operator).

    lte?: Literal

    Inclusive upper bound constraint (<= operator).

    gte?: Literal

    Inclusive lower bound constraint (>= operator).

    like?: string

    Text search constraint (~ operator).

    Matches values containing every whitespace-separated token of the search string as a case-insensitive substring.

    any?: Options

    Existential set matching constraint ("any of", ? operator).

    all?: Options

    Universal set matching constraint ("all of", ! operator).

    focus?: Options

    Sort focus (+ operator): resources whose value is among the options rank first, ahead of the sort order.

    order?: number

    Sort-key precedence (^ operator). The absolute value sets the position across sort keys; the sign sets the direction. The "asc"/"desc" shorthands are normalised to 1/-1.

    offset?: number

    Result-window offset (@ operator).

    limit?: number

    Result-window upper bound (# operator).