@ngutil/aria 0.0.102 → 0.0.105

package/gestures/gesture.d.ts

@@ -1,84 +0,0 @@
-import { Observable } from "rxjs";
-import { FunctionKeys, Mutable } from "utility-types";
-import { GestureDetail, GesturePointerType } from "./gesture-event";
-export declare enum GestureCaptureState {
-    Unchecked = 0,
-    Pending = 1,
-    Skip = 2,
-    Maybe = 3,
-    Instant = 4
-}
-type _GestureOptions = Partial<Omit<Gesture<any>, "originTypes" | "type" | FunctionKeys<Gesture<any>>>>;
-export type GestureOptions<T extends object> = Partial<Omit<T, keyof Gesture<any> | FunctionKeys<T>>> & _GestureOptions;
-export type GestureEvent<G extends Gesture> = G extends Gesture<infer E> & {
-    type: infer T;
-} ? CustomEvent<E> & {
-    type: T;
-} : never;
-export declare abstract class Gesture<T extends GestureDetail = GestureDetail> {
-    /**
-     * The name of the gesture
-     */
-    abstract readonly type: string;
-    /**
-     * Gestures that depends on move distance, like drag, use this option
-     */
-    readonly distanceInclusion: number;
-    /**
-     * Gestures thet dependnso on time frame, like longtap, use this option
-     */
-    readonly timeWithin: number;
-    /**
-     * The priority of the gesture
-     */
-    readonly priority: number;
-    /**
-     * Should the gesture include the scroll distance
-     */
-    readonly includeScrollDistance: boolean;
-    /**
-     * The pointer types of the gesture
-     */
-    readonly pointerTypes: Array<GesturePointerType>;
-    /**
-     * The number of pointers of the gesture can handle
-     */
-    readonly pointerCount: number;
-    /**
-     * The mouse buttons of the gesture (1 = left, 2 = middle, 3 = right)
-     */
-    readonly mouseButtons: Array<number>;
-    /**
-     * The event types of the gesture can handle
-     */
-    readonly originTypes: Array<string>;
-    constructor(options?: _GestureOptions);
-    /**
-     * Test if the gesture should be captured.
-     * The given events is filterde by {@see Gesture#shouldCapture}
-     * ! important, dont rely on this object state, because not always create a new object
-     * @param events events to check
-     */
-    abstract capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
-    /**
-     * Transform input event, to gesture event.
-     * The given events is filterde by {@see Gesture#isRelevantEvent}
-     * ! important, dont rely on this object state, because not always create a new object
-     * @param events events to transform or filter or leave as is
-     */
-    handle(events: Observable<GestureDetail>): Observable<Mutable<T>>;
-    /**
-     * Should this gesture capture the event?
-     * @param event event to check
-     * @returns true if the gesture should capture the event, false otherwise
-     */
-    shouldCapture(event: GestureDetail): boolean;
-    /**
-     * Test if the event is relevant to the gesture.
-     * The event is relevant if
-     * @param event event to check
-     * @returns true if the event is relevant, false otherwise
-     */
-    isRelevantEvent(event: GestureDetail): boolean;
-}
-export {};

package/gestures/gesture.service.d.ts

@@ -1,21 +0,0 @@
-import { Observable } from "rxjs";
-import { ElementInput } from "@ngutil/common";
-import { Gesture, GestureCaptureState, GestureEvent } from "./gesture";
-import * as i0 from "@angular/core";
-type GesturesToEventsType<T extends Array<Gesture>> = T extends Array<infer G> ? (G extends Gesture ? GestureEvent<G> : never) : never;
-type GestureEventDiscriminator<T> = T extends {
-    type: infer N;
-} ? {
-    type: N;
-} & T : never;
-export type GestureWatchReturns<T extends Array<Gesture>> = Observable<GestureEventDiscriminator<GesturesToEventsType<T>>>;
-export type GestureListenReturns<T extends Array<Gesture>> = Observable<GesturesToEventsType<T>>;
-export declare class GestureService {
-    #private;
-    constructor();
-    listen<T extends Array<Gesture>>(el: ElementInput, ...gestures: T): GestureListenReturns<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GestureService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GestureService>;
-}
-export declare function reduceCaptureStates(states: GestureCaptureState[]): GestureCaptureState;
-export {};

package/gestures/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./gesture-drag";
-export * from "./gesture-event";
-export * from "./gesture-longtap";
-export * from "./gesture-tap";
-export * from "./gesture.service";
-export * from "./gesture";

package/keystroke/index.d.ts

@@ -1 +0,0 @@
-export * from "./keystroke.service";

package/keystroke/keystroke.service.d.ts

@@ -1,22 +0,0 @@
-import { Observable } from "rxjs";
-import { ElementInput } from "@ngutil/common";
-import { FocusState } from "../focus";
-import * as i0 from "@angular/core";
-export interface Keystroke {
-    key: KeyboardEvent["key"];
-    shift?: boolean;
-    ctrl?: boolean;
-    alt?: boolean;
-    state: "down" | "up";
-}
-export interface KeystrokeEvent {
-    original: KeyboardEvent;
-    keystroke: Keystroke;
-}
-export type KeystrokeActivation = ElementInput | FocusState | Observable<ElementInput | FocusState | boolean>;
-export declare class KeystrokeService {
-    #private;
-    watch(activation: KeystrokeActivation, ...keystrokes: Keystroke[]): Observable<KeystrokeEvent>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KeystrokeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<KeystrokeService>;
-}

package/ui-state/abstract.d.ts

@@ -1,19 +0,0 @@
-import { Signal } from "@angular/core";
-import { Observable } from "rxjs";
-import { UiState } from "./ui-state";
-import * as i0 from "@angular/core";
-export declare const NOTSET: any;
-export declare abstract class AbstractUiState<N extends string> {
-    readonly name: N;
-    readonly state: UiState<N>;
-    abstract readonly input: Signal<boolean>;
-    abstract readonly when: Signal<string>;
-    readonly yes: Signal<boolean>;
-    readonly no: Signal<boolean>;
-    constructor(name: N);
-    set(value: boolean, source: string): void;
-    intercept(source: string): <S>(src: Observable<S>) => Observable<S>;
-    wrap<T>(observable: Observable<T>, source: string): Observable<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractUiState<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractUiState<any>, never, never, {}, {}, never, never, true, never>;
-}

package/ui-state/busy.directive.d.ts

@@ -1,9 +0,0 @@
-import { AbstractUiState } from "./abstract";
-import * as i0 from "@angular/core";
-export declare class BusyDirective extends AbstractUiState<"busy"> {
-    readonly input: import("@angular/core").InputSignal<boolean>;
-    readonly when: import("@angular/core").InputSignal<string>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<BusyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BusyDirective, "[nuBusy], [nuBusyWhen]", ["busy"], { "input": { "alias": "nuBusy"; "required": false; "isSignal": true; }; "when": { "alias": "nuBusyWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/ui-state/dirty.directive.d.ts

@@ -1,9 +0,0 @@
-import { AbstractUiState } from "./abstract";
-import * as i0 from "@angular/core";
-export declare class DirtyDirective extends AbstractUiState<"dirty"> {
-    readonly input: import("@angular/core").InputSignal<boolean>;
-    readonly when: import("@angular/core").InputSignal<string>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<DirtyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DirtyDirective, "[nuDirty], [nuDirtyWhen]", ["dirty"], { "input": { "alias": "nuDirty"; "required": false; "isSignal": true; }; "when": { "alias": "nuDirtyWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/ui-state/disabled.directive.d.ts

@@ -1,9 +0,0 @@
-import { AbstractUiState } from "./abstract";
-import * as i0 from "@angular/core";
-export declare class DisabledDirective extends AbstractUiState<"disabled"> {
-    readonly input: import("@angular/core").InputSignal<boolean>;
-    readonly when: import("@angular/core").InputSignal<string>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledDirective, "[nuDisabled], [nuDisabledWhen]", ["disabled"], { "input": { "alias": "nuDisabled"; "required": false; "isSignal": true; }; "when": { "alias": "nuDisabledWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/ui-state/index.d.ts

@@ -1,17 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./busy.directive";
-import * as i2 from "./dirty.directive";
-import * as i3 from "./disabled.directive";
-import * as i4 from "./readonly.directive";
-export * from "./abstract";
-export * from "./busy.directive";
-export * from "./disabled.directive";
-export * from "./progress-state";
-export * from "./readonly.directive";
-export * from "./dirty.directive";
-export * from "./ui-state";
-export declare class UiStateModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<UiStateModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<UiStateModule, never, [typeof i1.BusyDirective, typeof i2.DirtyDirective, typeof i3.DisabledDirective, typeof i4.ReadonlyDirective], [typeof i1.BusyDirective, typeof i2.DirtyDirective, typeof i3.DisabledDirective, typeof i4.ReadonlyDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<UiStateModule>;
-}

package/ui-state/progress-state.d.ts

@@ -1,71 +0,0 @@
-import { Observable, Subject } from "rxjs";
-import { DeepReadonly } from "@ngutil/common";
-import * as i0 from "@angular/core";
-export interface ProgressCommon {
-    readonly message?: string;
-    readonly [other: string]: unknown;
-}
-export interface ProgressLax {
-    readonly type: "lax";
-    readonly predictedTime: number;
-}
-export interface ProgressFix {
-    readonly type: "fix";
-    readonly percent: number;
-}
-export type Progress = (ProgressLax | ProgressFix) & ProgressCommon;
-export interface ProgressSegmentInput {
-    readonly name: string;
-    readonly distribution?: number;
-    readonly progress: DeepReadonly<Progress>;
-}
-export interface ProgressSegement extends ProgressSegmentInput {
-    ratio: number;
-    share: number;
-    done: boolean;
-    laxBegin?: number;
-}
-export type ProgressSegements = {
-    [key: string]: ProgressSegement;
-};
-export declare class ProgressState {
-    #private;
-    readonly value$: Observable<DeepReadonly<ProgressSegements>>;
-    readonly value: import("@angular/core").Signal<{
-        readonly [x: string]: {
-            readonly ratio: number;
-            readonly share: number;
-            readonly done: boolean;
-            readonly laxBegin?: number | undefined;
-            readonly name: string;
-            readonly distribution?: number | undefined;
-            readonly progress: {
-                readonly [x: string]: unknown;
-                readonly type: "lax";
-                readonly predictedTime: number;
-                readonly message?: string | undefined;
-            } | {
-                readonly [x: string]: unknown;
-                readonly type: "fix";
-                readonly percent: number;
-                readonly message?: string | undefined;
-            };
-        };
-    } | undefined>;
-    readonly percent$: Observable<number>;
-    readonly percent: import("@angular/core").Signal<number | undefined>;
-    segment(name: string, distribution?: number): ProgressSegmentRef;
-    connect(state: ProgressState, name: string, distribution?: number): Observable<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressState, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ProgressState, never, never, {}, {}, never, never, true, never>;
-}
-export declare class ProgressSegmentRef {
-    #private;
-    readonly name: string;
-    set distribution(value: number | undefined);
-    get distribution(): number | undefined;
-    get value(): Progress | undefined;
-    constructor(subject: Subject<ProgressSegmentInput>, name: string, distribution?: number);
-    next(progress: Progress): this;
-    complete(): this;
-}

package/ui-state/readonly.directive.d.ts

@@ -1,9 +0,0 @@
-import { AbstractUiState } from "./abstract";
-import * as i0 from "@angular/core";
-export declare class ReadonlyDirective extends AbstractUiState<"readonly"> {
-    readonly input: import("@angular/core").InputSignal<boolean>;
-    readonly when: import("@angular/core").InputSignal<string>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadonlyDirective, "[nuReadonly], [nuReadonlyWhen]", ["readonly"], { "input": { "alias": "nuReadonly"; "required": false; "isSignal": true; }; "when": { "alias": "nuReadonlyWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/ui-state/selector.d.ts

@@ -1,60 +0,0 @@
-import type { UiStateDetails } from "./ui-state";
-export type CompiledSelector = (state: UiStateDetails) => boolean;
-export declare const enum TokenType {
-    Any = 1,
-    Name = 2,
-    Negate = 3,
-    Or = 4,
-    And = 5,
-    Subscript = 7,
-    MultiSubscript = 8
-}
-export interface AstBase {
-    begin: number;
-    end: number;
-}
-export interface AstAny extends AstBase {
-    type: TokenType.Any;
-}
-export interface AstName extends AstBase {
-    type: TokenType.Name;
-    value: string;
-}
-export interface AstNegate extends AstBase {
-    type: TokenType.Negate;
-    value: SelectorAst;
-}
-export interface AstOr extends AstBase {
-    type: TokenType.Or;
-    left: SelectorAst;
-    right: SelectorAst;
-}
-export interface AstAnd extends AstBase {
-    type: TokenType.And;
-    left: SelectorAst;
-    right: SelectorAst;
-}
-export interface AstSubscript extends AstBase {
-    type: TokenType.Subscript;
-    base: AstName;
-    subscript: AstAny | AstName;
-}
-export interface AstMultiSubscript extends AstBase {
-    type: TokenType.MultiSubscript;
-    base: AstName;
-    subscripts: AstName[];
-}
-export type SelectorAst = AstAny | AstName | AstNegate | AstOr | AstAnd | AstSubscript | AstMultiSubscript;
-export declare function compile(selector: string): CompiledSelector;
-/**
- * expression:
- *  - "*": any
- *  - "name without dot": top level: eg. "busy" or "disabled", this is equal to "busy.*"
- *  - "name with dot": nested: eg. "busy.self" or "busy.loading"
- *  - negate: "!busy", "!busy.*", "!busy.save"
- *  - OR: "busy.* || !disabled.*"
- *  - AND: "busy.* && !disabled.*"
- *  - GROUP: "(busy || disabled) && !readonly"
- *  - Shorted of multiple source of same base: "busy{load,save}", if one of load or save is true, the result is true
- */
-export declare function parse(selector: string): SelectorAst;

package/ui-state/ui-state.d.ts

@@ -1,36 +0,0 @@
-import { Observable } from "rxjs";
-import * as i0 from "@angular/core";
-/**
- * {
- *  busy: {
- *      self: true,
- *      parent: false,
- *      disabled: false
- *  }
- * }
- */
-export type UiStateDetails = {
-    readonly [key: string]: UiStateEntry;
-};
-export type UiStateEntry = {
-    readonly [key: UiStateSource]: boolean;
-};
-export type UiStateValue = {
-    readonly [key: string]: boolean;
-};
-export type UiStateSource = "parent" | "self" | string;
-export type UiStateSelector = string;
-export declare class UiState<N extends string = string, S extends UiStateSource = UiStateSource> {
-    #private;
-    get root(): UiState;
-    readonly merged: import("@angular/core").Signal<UiStateDetails>;
-    readonly value: import("@angular/core").Signal<UiStateValue>;
-    readonly inertSelector: import("@angular/core").WritableSignal<string>;
-    set(name: N, value: boolean, source?: S): void;
-    is(selector?: UiStateSelector): boolean;
-    intercept(name: N, source: S): <S_1>(src: Observable<S_1>) => Observable<S_1>;
-    wrap<T>(observable: Observable<T>, name: N, source: S): Observable<T>;
-    isInert(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UiState<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<UiState<any, any>, never, never, {}, {}, never, never, true, never>;
-}