native-document 1.0.15 → 1.0.16-8.1

package/src/ui/tokens/spacings.scss

@@ -0,0 +1,13 @@
+:root {
+  --space-tiny: 0.25rem;
+  --space-tight: 0.35rem;
+  --space-cozy: 0.5rem;
+  --space-cozy-comfortable: 0.75rem;
+  --space-comfortable: 1rem;
+  --space-relaxed: 1.5rem;
+  --space-loose: 2rem;
+  --space-spacious: 3rem;
+
+  --container-padding: 1rem;
+  --container-margin: 0rem;
+}

package/src/ui/tokens/vars.scss

@@ -0,0 +1,35 @@
+:root {
+  /* Primary */
+  --color-primary:          var(--blue);
+  --color-primary-hover:    var(--contrasted-blue);
+
+  /* Secondary */
+  --color-secondary:        var(--gray-lite-4);
+  --color-secondary-hover:  var(--gray-lite-3);
+  --color-secondary-text:   var(--text-color);
+
+  /* Danger */
+  --color-danger:           var(--red);
+  --color-danger-hover:     var(--contrasted-red);
+
+  /* Success */
+  --color-success:          var(--green);
+  --color-success-hover:    var(--contrasted-green);
+
+  /* Warning */
+  --color-warning:          var(--yellow);
+  --color-warning-hover:    var(--contrasted-yellow);
+
+  /* Info */
+  --color-info:             var(--cyan);
+  --color-info-hover:       var(--contrasted-cyan);
+
+  /* Ghost */
+  --color-ghost:            transparent;
+  --color-ghost-hover:      var(--gray-lite-5);
+  --color-ghost-text:       var(--text-color);
+
+  /* Link */
+  --color-link:             var(--blue);
+  --color-link-hover:       var(--contrasted-blue);
+}

package/src/ui/tokens/viewports.scss

@@ -0,0 +1,30 @@
+
+:root {
+  --mobile-width: 320px;
+  --tablet-width: 768px;
+  --desktop-width: 1024px;
+  --wide-desktop-width: 1280px;
+  --fullhd-width: 1440px;
+
+  --floor-layer: 0;
+  --noitifcation-layer: 1;
+  --dropdown-layer: 4;
+  --tooltip-layer: 2;
+  --overlay-layer: 10000;
+  --modal-layer: 10001;
+}
+
+@media only screen and (min-width: 768px) {
+  .mobile-only {
+    display: none;
+  }
+}
+
+@media only screen and (max-width: 768px) {
+  .desktop-only {
+    display: none;
+  }
+  .at-least-tablet {
+    display: none;
+  }
+}

package/types/args-types.d.ts

@@ -0,0 +1,58 @@
+import {ObservableItem} from "./observable";
+import {ValidChildren} from "./validator";
+
+type ValidateFunction<T = any> = (value: any) => value is T;
+
+interface ArgType<T = any> {
+    name: string;
+    type: string;
+    validate: ValidateFunction<T>;
+    optional?: boolean;
+}
+
+export interface OneOfArgType extends Omit<ArgType, 'validate'> {
+    type: 'oneOf';
+    types: ArgType[];
+    validate: (value: any) => boolean;
+}
+
+type AnyArgType = ArgType | OneOfArgType;
+
+type Element = HTMLElement | DocumentFragment | Text;
+
+export interface OptionalArgType<T = any> extends ArgType<T> {
+    optional: true;
+}
+
+export declare const ArgTypes: {
+    string: (name: string) => ArgType<string>;
+    number: (name: string) => ArgType<number>;
+    boolean: (name: string) => ArgType<boolean>;
+    observable: (name: string) => ArgType<ObservableItem>;
+    element: (name: string) => ArgType<Element>;
+    function: (name: string) => ArgType<Function>;
+    object: (name: string) => ArgType<object>;
+    objectNotNull: (name: string) => ArgType<NonNullable<object>>;
+    children: (name: string) => ArgType<ValidChildren>;
+    attributes: (name: string) => ArgType<any>;
+
+    optional: <T extends AnyArgType>(argType: T) => T & { optional: true };
+
+    oneOf: (name: string, ...argTypes: ArgType[]) => OneOfArgType;
+};
+
+type ArgSchema = AnyArgType[];
+
+export declare function withValidation<T extends (...args: any[]) => any>(
+    fn: T,
+    argSchema: ArgSchema,
+    fnName?: string
+): T;
+
+export declare function normalizeComponentArgs(
+    props: any,
+    children: any
+): {
+    props: any;
+    children: any;
+};

package/types/control-flow.d.ts

@@ -0,0 +1,62 @@
+// Control flow components type definitions
+import {ObservableItem, ObservableChecker, ObservableArray, ObservableWhen} from './observable';
+import { ValidChild } from './elements';
+
+// Control Flow Functions
+export interface ShowIfFunction {
+    (condition: ObservableItem<boolean> | ObservableChecker<boolean> | ObservableWhen, child: ValidChild, options?: { comment?: string | null; shouldKeepInCache?: boolean }): DocumentFragment;
+}
+
+export interface HideIfFunction {
+    (condition: ObservableItem<boolean> | ObservableChecker<boolean>, child: ValidChild, options?: { comment?: string | null; shouldKeepInCache?: boolean }): DocumentFragment;
+}
+
+export interface MatchFunction {
+    <T extends string | number>(condition: ObservableItem<T> | ObservableChecker<T>, values: Record<T, ValidChild>, shouldKeepInCache?: boolean): DocumentFragment & {
+        add(key: T, child: ValidChild, shouldFocusOn?: boolean): void;
+        remove(key: T): void;
+    };
+}
+
+export interface SwitchFunction {
+    (condition: ObservableItem<boolean> | ObservableChecker<boolean>, onTrue: ValidChild, onFalse: ValidChild): DocumentFragment;
+}
+
+export interface WhenFunction {
+    (condition: ObservableItem<boolean> | ObservableChecker<boolean>): {
+        show(onTrue: ValidChild): {
+            otherwise(onFalse: ValidChild): DocumentFragment;
+        };
+    };
+}
+
+export interface ForEachFunction {
+    <T>(data: T[] | Record<string, T> | ObservableItem<T[]> | ObservableItem<Record<string, T>>,
+        callback?: (item: T, index?: ObservableItem<number>) => ValidChild,
+        key?: string | ((item: T, defaultKey: string | number) => string | number),
+        options?: { shouldKeepItemsInCache: boolean, isParentUniqueChild: boolean,  }): DocumentFragment,
+}
+
+export interface ForEachArrayFunction {
+    <T>(data: ObservableArray<T>,
+        callback?: (item: T, index?: ObservableItem<number>) => ValidChild,
+        configs?: { isParentUniqueChild: boolean, shouldKeepItemsInCache?: boolean }): DocumentFragment;
+}
+
+export interface HideIfNotFunction {
+    (condition: ObservableItem<boolean> | ObservableChecker<boolean> | ObservableWhen, child: ValidChild, options?: { comment?: string | null; shouldKeepInCache?: boolean }): DocumentFragment;
+}
+
+
+export function ShowWhen(observerWhenResult: ObservableWhen, view: ValidChild): ReturnType<typeof ShowIf>;
+export function ShowWhen(observer: ObservableItem, target: any, view: ValidChild): ReturnType<typeof ShowIf>;
+
+// Control Flow Components
+export declare const ShowIf: ShowIfFunction;
+export declare const HideIf: HideIfFunction;
+export declare const HideIfNot: ShowIfFunction;
+export declare const Match: MatchFunction;
+export declare const Switch: SwitchFunction;
+export declare const When: WhenFunction;
+export declare const ForEach: ForEachFunction;
+export declare const ForEachArray: ForEachArrayFunction;

package/types/elements.d.ts

@@ -0,0 +1,231 @@
+// DOM elements and components type definitions
+import { ObservableItem } from './observable';
+import { BindingHydrator } from './template-cloner';
+import { NDElement } from './nd-element';
+
+// - Re-export all attribute types and utilities from globals
+export type {
+    Observable,
+    NdClassMap,
+    NdStyleMap,
+    NdAriaAttributes,
+    NdDataAttributes,
+    GlobalAttributes,
+    SharedFormAttributes,
+    AnchorAttributes,
+    ImgAttributes,
+    ButtonAttributes,
+    InputAttributes,
+    TextAreaAttributes,
+    SelectAttributes,
+    OptionAttributes,
+    FormAttributes,
+    VideoAttributes,
+    AudioAttributes,
+    CanvasAttributes,
+    DetailsAttributes,
+    DialogAttributes,
+    ProgressAttributes,
+    MeterAttributes,
+    SourceAttributes,
+    TrackAttributes,
+    ThAttributes,
+    TdAttributes,
+    LabelAttributes,
+    OutputAttributes,
+    TimeAttributes,
+    ModAttributes,
+    OlAttributes,
+    SvgAttributes,
+} from './globals';
+
+// ---------------------------------------------------------
+// ValidChild — accepted content for any NativeDocument element
+// ---------------------------------------------------------
+
+export type ValidChild =
+    | string
+    | number
+    | boolean
+    | null
+    | HTMLElement
+    | DocumentFragment
+    | Text
+    | ObservableItem
+    | NDElement
+    | BindingHydrator
+    | ValidChild[]
+    | ((...args: any[]) => ValidChild);
+
+// ---------------------------------------------------------
+// Internal element wrapper types
+// ---------------------------------------------------------
+
+type NdElement<T extends Element = HTMLElement> = T & { nd: NDElement };
+
+export type ElementFunction<A = GlobalAttributes, T extends Element = HTMLElement> =
+    (attributes?: A, children?: ValidChild) => NdElement<T>;
+
+export type ElementFunctionNoChildren<A = GlobalAttributes, T extends Element = HTMLElement> =
+    (attributes?: A) => NdElement<T>;
+
+export type NdHTMLElement<T extends HTMLElement = HTMLElement> = T & { nd: NDElement };
+
+// ---------------------------------------------------------
+// Text & structural elements
+// ---------------------------------------------------------
+
+export declare const Div:        ElementFunction<GlobalAttributes, HTMLDivElement>;
+export declare const Span:       ElementFunction<GlobalAttributes, HTMLSpanElement>;
+export declare const P:          ElementFunction<GlobalAttributes, HTMLParagraphElement>;
+export declare const Paragraph:  typeof P;
+export declare const Strong:     ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const H1:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const H2:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const H3:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const H4:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const H5:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const H6:         ElementFunction<GlobalAttributes, HTMLHeadingElement>;
+export declare const Pre:        ElementFunction<GlobalAttributes, HTMLPreElement>;
+export declare const Code:       ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Blockquote: ElementFunction<GlobalAttributes & { cite?: string }, HTMLQuoteElement>;
+export declare const Em:         ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Small:      ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Mark:       ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Del:        ElementFunction<ModAttributes, HTMLModElement>;
+export declare const Ins:        ElementFunction<ModAttributes, HTMLModElement>;
+export declare const Sub:        ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Sup:        ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Abbr:       ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Cite:       ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Q:          ElementFunction<GlobalAttributes & { cite?: string }, HTMLQuoteElement>;
+export declare const Dfn:        ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const I:          ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const B:          ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const U:          ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const S:          ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Hr:         ElementFunctionNoChildren<GlobalAttributes, HTMLHRElement>;
+export declare const Br:         ElementFunctionNoChildren<GlobalAttributes, HTMLBRElement>;
+
+// ---------------------------------------------------------
+// Layout & sectioning elements
+// ---------------------------------------------------------
+
+export declare const Section:  ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Article:  ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Aside:    ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Header:   ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Footer:   ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Main:     ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Nav:      ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Figure:   ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Figcaption: ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Details:  ElementFunction<DetailsAttributes, HTMLDetailsElement>;
+export declare const Summary:  ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Dialog:   ElementFunction<DialogAttributes, HTMLDialogElement>;
+export declare const Template: ElementFunctionNoChildren<GlobalAttributes, HTMLTemplateElement>;
+
+// ---------------------------------------------------------
+// List elements
+// ---------------------------------------------------------
+
+export declare const Ul:  ElementFunction<GlobalAttributes, HTMLUListElement>;
+export declare const Ol:  ElementFunction<OlAttributes, HTMLOListElement>;
+export declare const Li:  ElementFunction<GlobalAttributes, HTMLLIElement>;
+export declare const Dl:  ElementFunction<GlobalAttributes, HTMLDListElement>;
+export declare const Dt:  ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Dd:  ElementFunction<GlobalAttributes, HTMLElement>;
+
+// ---------------------------------------------------------
+// Link & media elements
+// ---------------------------------------------------------
+
+export declare const A:           ElementFunction<AnchorAttributes, HTMLAnchorElement>;
+export declare const Link:        typeof A;
+export declare const Video:       ElementFunction<VideoAttributes, HTMLVideoElement>;
+export declare const Audio:       ElementFunction<AudioAttributes, HTMLAudioElement>;
+export declare const Source:      ElementFunctionNoChildren<SourceAttributes, HTMLSourceElement>;
+export declare const Track:       ElementFunctionNoChildren<TrackAttributes, HTMLTrackElement>;
+export declare const Canvas:      ElementFunction<CanvasAttributes, HTMLCanvasElement>;
+export declare const Iframe:      ElementFunctionNoChildren<GlobalAttributes & {
+    src?:             string;
+    srcdoc?:          string;
+    name?:            string;
+    sandbox?:         string;
+    allow?:           string;
+    allowfullscreen?: boolean;
+    width?:           string | number;
+    height?:          string | number;
+    loading?:         'lazy' | 'eager';
+}, HTMLIFrameElement>;
+
+// ---------------------------------------------------------
+// SVG
+// ---------------------------------------------------------
+
+export declare const Svg:         ElementFunction<SvgAttributes, SVGSVGElement>;
+export declare const SvgPath:     ElementFunction<SvgAttributes, SVGPathElement>;
+export declare const SvgRect:     ElementFunction<SvgAttributes, SVGRectElement>;
+export declare const SvgCircle:   ElementFunction<SvgAttributes, SVGCircleElement>;
+export declare const SvgEllipse:  ElementFunction<SvgAttributes, SVGEllipseElement>;
+export declare const SvgLine:     ElementFunction<SvgAttributes, SVGLineElement>;
+export declare const SvgPolyline: ElementFunction<SvgAttributes, SVGPolylineElement>;
+export declare const SvgPolygon:  ElementFunction<SvgAttributes, SVGPolygonElement>;
+export declare const SvgG:        ElementFunction<SvgAttributes, SVGGElement>;
+export declare const SvgText:     ElementFunction<SvgAttributes, SVGTextElement>;
+export declare const SvgDefs:     ElementFunction<SvgAttributes, SVGDefsElement>;
+export declare const SvgUse:      ElementFunction<SvgAttributes, SVGUseElement>;
+
+// ---------------------------------------------------------
+// Table elements
+// ---------------------------------------------------------
+
+export declare const Table:   ElementFunction<GlobalAttributes, HTMLTableElement>;
+export declare const THead:   ElementFunction<GlobalAttributes, HTMLTableSectionElement>;
+export declare const TBody:   ElementFunction<GlobalAttributes, HTMLTableSectionElement>;
+export declare const TFoot:   ElementFunction<GlobalAttributes, HTMLTableSectionElement>;
+export declare const Tr:      ElementFunction<GlobalAttributes, HTMLTableRowElement>;
+export declare const TRow:    typeof Tr;
+export declare const Th:      ElementFunction<ThAttributes, HTMLTableCellElement>;
+export declare const THeadCell: typeof Th;
+export declare const TFootCell: typeof Th;
+export declare const Td:      ElementFunction<TdAttributes, HTMLTableCellElement>;
+export declare const TBodyCell: typeof Td;
+
+// ---------------------------------------------------------
+// Misc elements
+// ---------------------------------------------------------
+
+export declare const Time:    ElementFunction<TimeAttributes, HTMLTimeElement>;
+export declare const Data:    ElementFunction<GlobalAttributes & { value?: import('./globals').Observable<string> }, HTMLDataElement>;
+export declare const Address: ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Kbd:     ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Samp:    ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Var:     ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const Wbr:     ElementFunctionNoChildren<GlobalAttributes, HTMLElement>;
+
+// ---------------------------------------------------------
+// Fragment & Anchor utilities
+// ---------------------------------------------------------
+
+export declare const Fragment:               ElementFunction<GlobalAttributes, HTMLElement>;
+export declare const NativeDocumentFragment: typeof Anchor;
+
+export declare type AnchorDocumentFragment = DocumentFragment & {
+    detach():                                                           void;
+    restore():                                                          void;
+    clear():                                                            void;
+    remove():                                                           void;
+    removeChildren():                                                   void;
+    insertBefore(child: ValidChild, before: HTMLElement | Comment | null): void;
+    replaceContent(child: ValidChild):                                  void;
+    setContent(child: ValidChild):                                      void;
+    appendElement(child: ValidChild, before: HTMLElement | Comment | null): void;
+    append(...args: ValidChild[]):                                      void;
+    getByIndex(index: number):                                          HTMLElement | null;
+    endElement():                                                       Comment;
+    startElement():                                                     Comment;
+    removeWithAnchors():                                                void;
+};
+
+export declare function Anchor(name?: string, isUniqueChild?: boolean): AnchorDocumentFragment;

package/types/filters/dates.d.ts

@@ -0,0 +1,43 @@
+import { ObservableItem } from '../observable';
+import { FilterResult } from './types';
+
+export type DateValue = Date | string | number | ObservableItem<Date | string | number>;
+
+export function toDate(value: Date | string | number): Date;
+
+export function isSameDay(date1: Date | string | number, date2: Date | string | number): boolean;
+
+export function getSecondsOfDay(date: Date | string | number): number;
+
+export function dateEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function timeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function dateTimeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;

package/types/filters/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './dates';
+export * from './standard';
+export * from './strings';

package/types/filters/standard.d.ts

@@ -0,0 +1,70 @@
+import { ObservableOrValue, FilterResult } from './types';
+
+
+export function equals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function notEquals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function between<T extends number | Date>(
+    minObservableOrValue: ObservableOrValue<T>,
+    maxObservableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function inArray<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function notIn<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function isEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function isNotEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function match(
+    patternObservableOrValue: ObservableOrValue<string | RegExp>,
+    asRegexObservableOrValue?: ObservableOrValue<boolean>,
+    flagsObservableOrValue?: ObservableOrValue<string>
+): FilterResult<string | RegExp>;
+
+export function and<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function or<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function not<T>(filter: FilterResult<T>): FilterResult<T>;
+
+
+
+export const gt: typeof greaterThan;
+export const gte: typeof greaterThanOrEqual;
+export const lt: typeof lessThan;
+export const lte: typeof lessThanOrEqual;
+export const eq: typeof equals;
+export const neq: typeof notEquals;
+export const all: typeof and;
+export const any: typeof or;

package/types/filters/strings.d.ts

@@ -0,0 +1,21 @@
+import {FilterResult, ObservableOrValue} from './types';
+
+export function contains(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function includes(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function startsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function endsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;

package/types/filters/types.d.ts

@@ -0,0 +1,20 @@
+import { ObservableItem } from '../observable';
+
+export interface FilterResult<T = any> {
+    dependencies: ObservableItem | ObservableItem[] | null;
+    callback: (value: T) => boolean;
+}
+
+export type ObservableOrValue<T> = T | ObservableItem<T>;
+
+export type Predicate<T = any> =
+    | T
+    | ((value: T) => boolean)
+    | FilterResult<T>
+    | ObservableItem<T>;
+
+export type PredicateMap<T> = {
+    [K in keyof T]?: Predicate<T[K]>;
+} & {
+    _?: FilterResult<T>;
+};