@ngutil/aria 0.0.101 → 0.0.104

package/index.d.ts

@@ -1,5 +1,436 @@
-export { ActivityEvent, ActivityOrigin, ActivityService } from "./activity";
-export { Keystroke, KeystrokeEvent, KeystrokeService } from "./keystroke";
-export * from "./focus";
-export * from "./gestures";
-export * from "./ui-state";
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { ElementInput, Destructible, ConnectProtocol, DeepReadonly } from '@ngutil/common';
+import * as _angular_cdk_a11y_module_d from '@angular/cdk/a11y-module.d';
+import { FocusableElement } from 'tabbable';
+import * as utility_types from 'utility-types';
+import { FunctionKeys, Mutable } from 'utility-types';
+import { Position } from '@ngutil/style';
+
+type ActivityOrigin = "mouse" | "keyboard" | "touch" | "program";
+interface ActivityEvent {
+    origin: ActivityOrigin;
+    type: keyof typeof EVENT_ORIGIN;
+    node?: Node;
+}
+declare const EVENT_ORIGIN: {
+    keydown: string;
+    mousedown: string;
+    mousemove: string;
+    touchstart: string;
+};
+declare class ActivityService {
+    #private;
+    readonly events$: Observable<ActivityEvent>;
+    watchActivity(node?: HTMLElement): Observable<ActivityEvent>;
+    watchInactvity(timeout: number): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityService>;
+}
+
+type FocusOrigin = ActivityOrigin | null;
+interface FocusOriginEvent {
+    element: Node;
+    origin: FocusOrigin;
+}
+declare class FocusService {
+    #private;
+    readonly events: Observable<FocusOriginEvent>;
+    watch(element: ElementInput): Observable<FocusOriginEvent>;
+    focus(node: ElementInput, origin?: ActivityOrigin): void;
+    queryFocusable(inside: ElementInput): FocusableElement[];
+    getFirstFocusable(inside: ElementInput): FocusableElement | undefined;
+    isFocusable(node: ElementInput): boolean;
+    focusTrap(inside: ElementInput, deferCaptureElements?: boolean): _angular_cdk_a11y_module_d.FocusTrap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusService>;
+}
+
+declare class FocusTrap extends Destructible {
+    #private;
+    get enabled(): boolean;
+    set enabled(val: boolean);
+    enable(): void;
+    disable(): void;
+}
+
+declare class FocusState implements ConnectProtocol {
+    #private;
+    readonly event$: Observable<FocusOriginEvent>;
+    readonly event: i0.Signal<FocusOriginEvent | undefined>;
+    readonly self: i0.Signal<FocusOrigin>;
+    readonly within: i0.Signal<FocusOrigin>;
+    readonly has: i0.Signal<FocusOrigin>;
+    constructor();
+    connect(value: FocusState | ElementInput): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusState, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusState, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class Focusable implements ConnectProtocol {
+    readonly state: FocusState;
+    readonly focusable: i0.InputSignal<number | boolean>;
+    readonly tabindex: i0.InputSignalWithTransform<number, any>;
+    readonly _tabindex: i0.Signal<number>;
+    connect(value: Focusable | FocusState | ElementInput): rxjs.Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Focusable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Focusable, "[nuFocusable]", ["nuFocusable"], { "focusable": { "alias": "nuFocusable"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof FocusState; inputs: {}; outputs: {}; }]>;
+}
+
+interface Keystroke {
+    key: KeyboardEvent["key"];
+    shift?: boolean;
+    ctrl?: boolean;
+    alt?: boolean;
+    state: "down" | "up";
+}
+interface KeystrokeEvent {
+    original: KeyboardEvent;
+    keystroke: Keystroke;
+}
+type KeystrokeActivation = ElementInput | FocusState | Observable<ElementInput | FocusState | boolean>;
+declare class KeystrokeService {
+    #private;
+    watch(activation: KeystrokeActivation, ...keystrokes: Keystroke[]): Observable<KeystrokeEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeystrokeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeystrokeService>;
+}
+
+interface GestureDetail {
+    readonly origin: GestureOrigin;
+    readonly target: HTMLElement;
+    readonly pointerType: GesturePointerType;
+    readonly phase: GesturePhase;
+    readonly pointers: ReadonlyArray<GesturePointer>;
+    readonly timeStamp: number;
+    readonly elapsed: number;
+    readonly scrollDistance?: Position;
+}
+type PointersPosition = ReadonlyArray<Readonly<Position>>;
+interface GesturePointer {
+    readonly start: Position;
+    readonly current: Position;
+    readonly end?: Position;
+    readonly distance: Position;
+    readonly direction: {
+        x: -1 | 0 | 1;
+        y: -1 | 0 | 1;
+    };
+}
+type GestureOrigin = MouseEvent | TouchEvent;
+declare enum GesturePointerType {
+    Mouse = "mouse",
+    Touch = "touch"
+}
+declare enum GesturePhase {
+    Start = "start",
+    Moving = "moving",
+    End = "end"
+}
+interface GestureListenerConfig {
+    options?: AddEventListenerOptions;
+    pointerType: GesturePointerType;
+    phase: GesturePhase;
+}
+declare const Listeners: {
+    [key: string]: GestureListenerConfig;
+};
+
+declare enum GestureCaptureState {
+    Unchecked = 0,
+    Pending = 1,
+    Skip = 2,
+    Maybe = 3,
+    Instant = 4
+}
+type _GestureOptions = Partial<Omit<Gesture<any>, "originTypes" | "type" | FunctionKeys<Gesture<any>>>>;
+type GestureOptions<T extends object> = Partial<Omit<T, keyof Gesture<any> | FunctionKeys<T>>> & _GestureOptions;
+type GestureEvent<G extends Gesture> = G extends Gesture<infer E> & {
+    type: infer T;
+} ? CustomEvent<E> & {
+    type: T;
+} : never;
+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;
+}
+
+interface GestureDragDetail extends GestureDetail {
+    moveBy: Position;
+}
+type GestureDragOptions = GestureOptions<GestureDragImpl>;
+declare class GestureDragImpl<T extends GestureDragDetail = GestureDragDetail> extends Gesture<T> {
+    readonly type = "gesture-drag";
+    readonly horizontal?: boolean;
+    readonly vertical?: boolean;
+    constructor(options?: GestureDragOptions);
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<Mutable<T>>;
+}
+declare function gestureDrag(options?: GestureDragOptions): GestureDragImpl<GestureDragDetail>;
+declare const GestureDrag: GestureDragImpl<GestureDragDetail>;
+declare const GestureDragHorizontal: GestureDragImpl<GestureDragDetail>;
+declare const GestureDragVertical: GestureDragImpl<GestureDragDetail>;
+
+type GestureLongTapDetail = GestureDetail;
+type GestureLongTapOptions = GestureOptions<GestureLongTapImpl>;
+declare class GestureLongTapImpl<T extends GestureLongTapDetail = GestureLongTapDetail> extends Gesture<T> {
+    readonly type = "gesture-longtap";
+    constructor(options?: GestureLongTapOptions);
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<utility_types.Mutable<T>>;
+}
+declare function gestureLongTap(options?: GestureLongTapOptions): GestureLongTapImpl<GestureDetail>;
+declare const GestureLongTap: GestureLongTapImpl<GestureDetail>;
+
+type GestureTapDetail = GestureDetail;
+type GestureTapOptions = GestureOptions<GestureTapImpl>;
+declare class GestureTapImpl<T extends GestureTapDetail = GestureTapDetail> extends Gesture<T> {
+    readonly type = "gesture-tap";
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<utility_types.Mutable<T>>;
+}
+declare function gestureTap(options?: GestureTapOptions): GestureTapImpl<GestureDetail>;
+declare const GestureTap: GestureTapImpl<GestureDetail>;
+
+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;
+type GestureWatchReturns<T extends Array<Gesture>> = Observable<GestureEventDiscriminator<GesturesToEventsType<T>>>;
+type GestureListenReturns<T extends Array<Gesture>> = Observable<GesturesToEventsType<T>>;
+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>;
+}
+declare function reduceCaptureStates(states: GestureCaptureState[]): GestureCaptureState;
+
+/**
+ * {
+ *  busy: {
+ *      self: true,
+ *      parent: false,
+ *      disabled: false
+ *  }
+ * }
+ */
+type UiStateDetails = {
+    readonly [key: string]: UiStateEntry;
+};
+type UiStateEntry = {
+    readonly [key: UiStateSource]: boolean;
+};
+type UiStateValue = {
+    readonly [key: string]: boolean;
+};
+type UiStateSource = "parent" | "self" | string;
+type UiStateSelector = string;
+declare class UiState<N extends string = string, S extends UiStateSource = UiStateSource> {
+    #private;
+    get root(): UiState;
+    readonly merged: i0.Signal<UiStateDetails>;
+    readonly value: i0.Signal<UiStateValue>;
+    readonly inertSelector: i0.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>;
+}
+
+declare const NOTSET: any;
+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>;
+}
+
+declare class BusyDirective extends AbstractUiState<"busy"> {
+    readonly input: i0.InputSignal<boolean>;
+    readonly when: i0.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>;
+}
+
+declare class DirtyDirective extends AbstractUiState<"dirty"> {
+    readonly input: i0.InputSignal<boolean>;
+    readonly when: i0.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>;
+}
+
+declare class DisabledDirective extends AbstractUiState<"disabled"> {
+    readonly input: i0.InputSignal<boolean>;
+    readonly when: i0.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>;
+}
+
+declare class ReadonlyDirective extends AbstractUiState<"readonly"> {
+    readonly input: i0.InputSignal<boolean>;
+    readonly when: i0.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>;
+}
+
+interface ProgressCommon {
+    readonly message?: string;
+    readonly [other: string]: unknown;
+}
+interface ProgressLax {
+    readonly type: "lax";
+    readonly predictedTime: number;
+}
+interface ProgressFix {
+    readonly type: "fix";
+    readonly percent: number;
+}
+type Progress = (ProgressLax | ProgressFix) & ProgressCommon;
+interface ProgressSegmentInput {
+    readonly name: string;
+    readonly distribution?: number;
+    readonly progress: DeepReadonly<Progress>;
+}
+interface ProgressSegement extends ProgressSegmentInput {
+    ratio: number;
+    share: number;
+    done: boolean;
+    laxBegin?: number;
+}
+type ProgressSegements = {
+    [key: string]: ProgressSegement;
+};
+declare class ProgressState {
+    #private;
+    readonly value$: Observable<DeepReadonly<ProgressSegements>>;
+    readonly value: i0.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: i0.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>;
+}
+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;
+}
+
+declare class UiStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UiStateModule, never, [typeof BusyDirective, typeof DirtyDirective, typeof DisabledDirective, typeof ReadonlyDirective], [typeof BusyDirective, typeof DirtyDirective, typeof DisabledDirective, typeof ReadonlyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UiStateModule>;
+}
+
+export { AbstractUiState, ActivityService, BusyDirective, DirtyDirective, DisabledDirective, FocusService, FocusState, FocusTrap, Focusable, Gesture, GestureCaptureState, GestureDrag, GestureDragHorizontal, GestureDragImpl, GestureDragVertical, GestureLongTap, GestureLongTapImpl, GesturePhase, GesturePointerType, GestureService, GestureTap, GestureTapImpl, KeystrokeService, Listeners, NOTSET, ProgressSegmentRef, ProgressState, ReadonlyDirective, UiState, UiStateModule, gestureDrag, gestureLongTap, gestureTap, reduceCaptureStates };
+export type { ActivityEvent, ActivityOrigin, FocusOrigin, FocusOriginEvent, GestureDetail, GestureDragDetail, GestureDragOptions, GestureEvent, GestureListenReturns, GestureListenerConfig, GestureLongTapDetail, GestureLongTapOptions, GestureOptions, GestureOrigin, GesturePointer, GestureTapDetail, GestureTapOptions, GestureWatchReturns, Keystroke, KeystrokeEvent, PointersPosition, Progress, ProgressCommon, ProgressFix, ProgressLax, ProgressSegement, ProgressSegements, ProgressSegmentInput, UiStateDetails, UiStateEntry, UiStateSelector, UiStateSource, UiStateValue };

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@ngutil/aria",
-  "version": "0.0.101",
+  "version": "0.0.104",
   "peerDependencies": {
-    "@angular/cdk": "19.2.11",
-    "@angular/common": "19.2.8",
-    "@angular/core": "19.2.8",
+    "@angular/cdk": "20.2.14",
+    "@angular/common": "20.3.13",
+    "@angular/core": "20.3.13",
     "es-toolkit": "^1.35.0",
     "rxjs": "^7.8.1",
     "tabbable": "^6.2.0",
     "utility-types": "^3.11.0",
-    "@ngutil/common": "0.0.101",
-    "@ngutil/style": "0.0.101"
+    "@ngutil/common": "0.0.104",
+    "@ngutil/style": "0.0.104"
   },
   "publishConfig": {
     "access": "public",

package/activity/activity.service.d.ts

@@ -1,23 +0,0 @@
-import { Observable } from "rxjs";
-import * as i0 from "@angular/core";
-export type ActivityOrigin = "mouse" | "keyboard" | "touch" | "program";
-export interface ActivityEvent {
-    origin: ActivityOrigin;
-    type: keyof typeof EVENT_ORIGIN;
-    node?: Node;
-}
-declare const EVENT_ORIGIN: {
-    keydown: string;
-    mousedown: string;
-    mousemove: string;
-    touchstart: string;
-};
-export declare class ActivityService {
-    #private;
-    readonly events$: Observable<ActivityEvent>;
-    watchActivity(node?: HTMLElement): Observable<ActivityEvent>;
-    watchInactvity(timeout: number): Observable<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityService>;
-}
-export {};

package/activity/index.d.ts

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

package/focus/focus-state.directive.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from "rxjs";
-import { ConnectProtocol, ElementInput } from "@ngutil/common";
-import { FocusOrigin, FocusOriginEvent } from "./focus.service";
-import * as i0 from "@angular/core";
-export declare class FocusState implements ConnectProtocol {
-    #private;
-    readonly event$: Observable<FocusOriginEvent>;
-    readonly event: import("@angular/core").Signal<FocusOriginEvent | undefined>;
-    readonly self: import("@angular/core").Signal<FocusOrigin>;
-    readonly within: import("@angular/core").Signal<FocusOrigin>;
-    readonly has: import("@angular/core").Signal<FocusOrigin>;
-    constructor();
-    connect(value: FocusState | ElementInput): Observable<unknown>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusState, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusState, never, never, {}, {}, never, never, true, never>;
-}

package/focus/focus-trap.directive.d.ts

@@ -1,8 +0,0 @@
-import { Destructible } from "@ngutil/common";
-export declare class FocusTrap extends Destructible {
-    #private;
-    get enabled(): boolean;
-    set enabled(val: boolean);
-    enable(): void;
-    disable(): void;
-}

package/focus/focus.service.d.ts

@@ -1,22 +0,0 @@
-import { Observable } from "rxjs";
-import { type FocusableElement } from "tabbable";
-import { ElementInput } from "@ngutil/common";
-import { ActivityOrigin } from "../activity";
-import * as i0 from "@angular/core";
-export type FocusOrigin = ActivityOrigin | null;
-export interface FocusOriginEvent {
-    element: Node;
-    origin: FocusOrigin;
-}
-export declare class FocusService {
-    #private;
-    readonly events: Observable<FocusOriginEvent>;
-    watch(element: ElementInput): Observable<FocusOriginEvent>;
-    focus(node: ElementInput, origin?: ActivityOrigin): void;
-    queryFocusable(inside: ElementInput): FocusableElement[];
-    getFirstFocusable(inside: ElementInput): FocusableElement | undefined;
-    isFocusable(node: ElementInput): boolean;
-    focusTrap(inside: ElementInput, deferCaptureElements?: boolean): import("@angular/cdk/a11y-module.d-DrV0SO0k").FocusTrap;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FocusService>;
-}

package/focus/focusable.directive.d.ts

@@ -1,13 +0,0 @@
-import { ConnectProtocol, ElementInput } from "@ngutil/common";
-import { FocusState } from "./focus-state.directive";
-import * as i0 from "@angular/core";
-import * as i1 from "./focus-state.directive";
-export declare class Focusable implements ConnectProtocol {
-    readonly state: FocusState;
-    readonly focusable: import("@angular/core").InputSignal<number | boolean>;
-    readonly tabindex: import("@angular/core").InputSignalWithTransform<number, any>;
-    readonly _tabindex: import("@angular/core").Signal<number>;
-    connect(value: Focusable | FocusState | ElementInput): import("rxjs").Observable<unknown>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Focusable, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<Focusable, "[nuFocusable]", ["nuFocusable"], { "focusable": { "alias": "nuFocusable"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.FocusState; inputs: {}; outputs: {}; }]>;
-}

package/focus/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./focus.service";
-export * from "./focus-trap.directive";
-export * from "./focusable.directive";
-export * from "./focus-state.directive";

package/gestures/gesture-drag.d.ts

@@ -1,21 +0,0 @@
-import { Observable } from "rxjs";
-import { Mutable } from "utility-types";
-import { Position } from "@ngutil/style";
-import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureDetail } from "./gesture-event";
-export interface GestureDragDetail extends GestureDetail {
-    moveBy: Position;
-}
-export type GestureDragOptions = GestureOptions<GestureDragImpl>;
-export declare class GestureDragImpl<T extends GestureDragDetail = GestureDragDetail> extends Gesture<T> {
-    readonly type = "gesture-drag";
-    readonly horizontal?: boolean;
-    readonly vertical?: boolean;
-    constructor(options?: GestureDragOptions);
-    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureDetail>): Observable<Mutable<T>>;
-}
-export declare function gestureDrag(options?: GestureDragOptions): GestureDragImpl<GestureDragDetail>;
-export declare const GestureDrag: GestureDragImpl<GestureDragDetail>;
-export declare const GestureDragHorizontal: GestureDragImpl<GestureDragDetail>;
-export declare const GestureDragVertical: GestureDragImpl<GestureDragDetail>;

package/gestures/gesture-event.d.ts

@@ -1,40 +0,0 @@
-import { Position } from "@ngutil/style";
-export interface GestureDetail {
-    readonly origin: GestureOrigin;
-    readonly target: HTMLElement;
-    readonly pointerType: GesturePointerType;
-    readonly phase: GesturePhase;
-    readonly pointers: ReadonlyArray<GesturePointer>;
-    readonly timeStamp: number;
-    readonly elapsed: number;
-    readonly scrollDistance?: Position;
-}
-export type PointersPosition = ReadonlyArray<Readonly<Position>>;
-export interface GesturePointer {
-    readonly start: Position;
-    readonly current: Position;
-    readonly end?: Position;
-    readonly distance: Position;
-    readonly direction: {
-        x: -1 | 0 | 1;
-        y: -1 | 0 | 1;
-    };
-}
-export type GestureOrigin = MouseEvent | TouchEvent;
-export declare enum GesturePointerType {
-    Mouse = "mouse",
-    Touch = "touch"
-}
-export declare enum GesturePhase {
-    Start = "start",
-    Moving = "moving",
-    End = "end"
-}
-export interface GestureListenerConfig {
-    options?: AddEventListenerOptions;
-    pointerType: GesturePointerType;
-    phase: GesturePhase;
-}
-export declare const Listeners: {
-    [key: string]: GestureListenerConfig;
-};

package/gestures/gesture-longtap.d.ts

@@ -1,13 +0,0 @@
-import { Observable } from "rxjs";
-import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureDetail } from "./gesture-event";
-export type GestureLongTapDetail = GestureDetail;
-export type GestureLongTapOptions = GestureOptions<GestureLongTapImpl>;
-export declare class GestureLongTapImpl<T extends GestureLongTapDetail = GestureLongTapDetail> extends Gesture<T> {
-    readonly type = "gesture-longtap";
-    constructor(options?: GestureLongTapOptions);
-    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureDetail>): Observable<import("utility-types").Mutable<T>>;
-}
-export declare function gestureLongTap(options?: GestureLongTapOptions): GestureLongTapImpl<GestureDetail>;
-export declare const GestureLongTap: GestureLongTapImpl<GestureDetail>;

package/gestures/gesture-tap.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from "rxjs";
-import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureDetail } from "./gesture-event";
-export type GestureTapDetail = GestureDetail;
-export type GestureTapOptions = GestureOptions<GestureTapImpl>;
-export declare class GestureTapImpl<T extends GestureTapDetail = GestureTapDetail> extends Gesture<T> {
-    readonly type = "gesture-tap";
-    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureDetail>): Observable<import("utility-types").Mutable<T>>;
-}
-export declare function gestureTap(options?: GestureTapOptions): GestureTapImpl<GestureDetail>;
-export declare const GestureTap: GestureTapImpl<GestureDetail>;