@ngneers/controls 0.0.1-next.0

package/types/ngneers-controls-upload.d.ts

@@ -0,0 +1,347 @@
+import * as _ngneers_controls_custom_types from '@ngneers/controls-custom-types';
+import * as _iconify_types from '@iconify/types';
+import * as _angular_core from '@angular/core';
+import * as _ngneers_signal_translate from '@ngneers/signal-translate';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { NgnBase } from '@ngneers/controls/base';
+
+/**
+ * The lifecycle state of a single {@link NgnUploadFile}.
+ *
+ * - `pending` — queued, not yet handed to the consumer (manual mode, or pre-emit).
+ * - `uploading` — emitted via `(upload)`, the consumer is transferring it.
+ * - `done` — the consumer reported success via `markDone`.
+ * - `failed` — the consumer reported an error via `markFailed`.
+ * - `cancelled` — dismissed while in-flight; the item is removed from the list
+ *   but settles the upload promise in this terminal state.
+ */
+type NgnUploadFileState = 'pending' | 'uploading' | 'done' | 'failed' | 'cancelled';
+/**
+ * A file tracked by {@link NgnUpload}. Wraps the native {@link File} with the
+ * control-owned {@link id} (used to report progress/status back through the
+ * `exportAs` handle) and the current lifecycle {@link state}.
+ *
+ * The control cannot observe the real upload — the consumer runs the request —
+ * so {@link progress} is only meaningful once the consumer wires it back via
+ * `setProgress`. It stays `0` (rendered as an indeterminate bar while
+ * `uploading`) until then.
+ */
+interface NgnUploadFile {
+    /** Stable, control-generated id. Use it to call back through the handle. */
+    readonly id: string;
+    /** The native file selected or dropped by the user. */
+    readonly file: File;
+    /** Current lifecycle state. */
+    state: NgnUploadFileState;
+    /** Upload progress in the range `0`–`100`. `0` renders as indeterminate. */
+    progress: number;
+    /** Error reported by the consumer for a `failed` file, if any. */
+    error?: unknown;
+}
+
+/** How the user is allowed to add files to the drop zone. */
+type NgnUploadInteraction = 'click' | 'drag' | 'both';
+/**
+ * When selected/dropped files start uploading.
+ * - `auto` — instantly.
+ * - `confirm` — queued as `pending`; the user presses a rendered trigger.
+ * - `manual` — queued as `pending`; no trigger is rendered, upload starts only
+ *   via {@link NgnUpload.uploadAll}/{@link NgnUpload.uploadFile} from code.
+ */
+type NgnUploadMode = 'auto' | 'confirm' | 'manual';
+/** Which trigger(s) are rendered in `confirm` mode. */
+type NgnUploadConfirmTrigger = 'all' | 'per-item' | 'both';
+/** Where the file list renders relative to the drop zone. */
+type NgnUploadListPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * A file drop zone that wraps a **consumer-provided** native `input[type=file]`.
+ * Project the input as content and configure its native features there
+ * (`accept`, `multiple`, `name`, size limits, …) — the control discovers it,
+ * hides it, and drives it:
+ *
+ * ```html
+ * <ngn-upload #up="ngnUpload" mode="auto" (upload)="send($event, up)">
+ *   <input type="file" multiple accept="image/*" />
+ * </ngn-upload>
+ * ```
+ *
+ * The control owns the list of {@link NgnUploadFile}s and their lifecycle
+ * state, but it **cannot** observe the actual transfer (the consumer runs the
+ * request). Report progress/status back through the `exportAs="ngnUpload"`
+ * handle: {@link setProgress}, {@link markDone}, {@link markFailed}.
+ *
+ * @category control
+ */
+declare class NgnUpload extends NgnBase<'upload'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"upload", ["root", "dragover", "disabled", "clickable", "draggable", "has-files", "list-top", "list-bottom", "list-left", "list-right", "main", "zone", "icon", "placeholder", "list", "item", "item-pending", "item-uploading", "item-done", "item-failed", "status", "file", "name", "size", "progress", "actions", "action", "footer", "trigger"], readonly []>>;
+    protected readonly i18n: _ngneers_signal_translate.TranslationsSignal<{
+        calendar: {
+            today: string;
+            input: string;
+            selectYear: string;
+            selectMonth: string;
+            previousMonth: string;
+            nextMonth: string;
+            weekdays: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            weekdaysShort: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            months: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        editInplace: {
+            placeholder: string;
+            confirm: string;
+        };
+        filter: {
+            noFilter: string;
+            addCondition: string;
+            removeCondition: string;
+            operator: string;
+            value: string;
+            clear: string;
+            apply: string;
+            cancel: string;
+            matchModeLabel: string;
+            match: {
+                all: string;
+                any: string;
+                and: string;
+                or: string;
+            };
+            selected: string;
+            conditions: string;
+            operators: {
+                isEqual: string;
+                isNotEqual: string;
+                contains: string;
+                startsWith: string;
+                endsWith: string;
+                in: string;
+                isEmpty: string;
+                isNotEmpty: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+                after: string;
+                onOrAfter: string;
+                before: string;
+                onOrBefore: string;
+                isTrue: string;
+                isFalse: string;
+                custom: string;
+            };
+        };
+        splitter: {
+            handleLabel: string;
+        };
+        inputField: {
+            clearInput: string;
+        };
+        maskInput: {
+            roleDescription: string;
+            segmentRange: string;
+            optionSeparator: string;
+        };
+        drawer: {
+            close: string;
+        };
+        dialog: {
+            close: string;
+        };
+        chip: {
+            close: string;
+        };
+        breadcrumb: {
+            overflow: string;
+        };
+        toast: {
+            close: string;
+            region: string;
+        };
+        snackbar: {
+            close: string;
+            region: string;
+            severity: {
+                error: string;
+                warning: string;
+                success: string;
+                info: string;
+            };
+        };
+        upload: {
+            upload: string;
+            uploadNamed: string;
+            retryNamed: string;
+            cancelNamed: string;
+            removeNamed: string;
+            progressNamed: string;
+        };
+        select: {
+            filterOptions: string;
+        };
+        paginator: {
+            previousPage: string;
+            nextPage: string;
+        };
+        listBox: {
+            noItemsFound: string;
+        };
+        tree: {
+            noItemsFound: string;
+        };
+        table: {
+            selectAllRows: string;
+            selectRow: string;
+            sortedBy: string;
+            sortAscending: string;
+            sortDescending: string;
+            sortCleared: string;
+            selectedCount: string;
+            page: string;
+            resultCount: string;
+        };
+        state: {
+            loading: string;
+            success: string;
+            warning: string;
+            error: string;
+            cancelled: string;
+        };
+    }, "_">;
+    /** Unique id for the placeholder, referenced as the native input's a11y name. */
+    protected readonly labelId: string;
+    /**
+     * How the user may add files.
+     * - `click` — only clicking the zone opens the picker.
+     * - `drag` — only dropping files works.
+     * - `both` — either.
+     * @default both
+     */
+    readonly interaction: _angular_core.InputSignal<NgnUploadInteraction>;
+    /**
+     * When uploads start: `auto` (instantly), `confirm` (user presses a rendered
+     * trigger), or `manual` (only via {@link uploadAll}/{@link uploadFile}).
+     * @default auto
+     */
+    readonly mode: _angular_core.InputSignal<NgnUploadMode>;
+    /**
+     * Provide a custom upload icon
+     */
+    readonly iconUpload: _angular_core.InputSignal<_iconify_types.IconifyIcon | _ngneers_controls_custom_types.NgnIconEntry | undefined>;
+    /**
+     * In `confirm` mode, which trigger(s) to render: a single "upload all" button
+     * (`all`), a button per pending item (`per-item`), or `both`.
+     * @default all
+     */
+    readonly confirmTrigger: _angular_core.InputSignal<NgnUploadConfirmTrigger>;
+    /**
+     * Disables all interaction.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Where the file list renders relative to the drop zone.
+     * @default bottom
+     */
+    readonly listPosition: _angular_core.InputSignal<NgnUploadListPosition>;
+    /**
+     * Emitted with the files to upload: on select/drop in `auto` mode, or when a
+     * manual trigger fires. The emitted items are already marked `uploading`.
+     */
+    readonly upload: _angular_core.OutputEmitterRef<NgnUploadFile[]>;
+    /** Emitted when a file is removed from the list. */
+    readonly remove: _angular_core.OutputEmitterRef<NgnUploadFile>;
+    /** Emitted when a `failed` file's retry is pressed (also re-emits `upload`). */
+    readonly retry: _angular_core.OutputEmitterRef<NgnUploadFile>;
+    /**
+     * Emitted when an in-flight file is dismissed (the item's remove/cancel
+     * action while `uploading`). Abort the request; the item is then removed.
+     */
+    readonly cancelUpload: _angular_core.OutputEmitterRef<NgnUploadFile>;
+    /** The tracked files, in insertion order. */
+    readonly files: _angular_core.WritableSignal<NgnUploadFile[]>;
+    protected readonly dragover: _angular_core.WritableSignal<boolean>;
+    protected readonly clickable: _angular_core.Signal<boolean>;
+    protected readonly draggable: _angular_core.Signal<boolean>;
+    protected readonly hasPending: _angular_core.Signal<boolean>;
+    protected readonly showUploadAll: _angular_core.Signal<boolean>;
+    protected readonly showPerItem: _angular_core.Signal<boolean>;
+    private readonly _nativeInput;
+    /** Resolvers awaiting a file (by id) reaching a terminal/settled state. */
+    private readonly _settlers;
+    constructor();
+    /** Report transfer progress (`0`–`100`) for a file; marks it `uploading`. */
+    setProgress(id: string, progress: number): void;
+    /** Mark a file as actively uploading. */
+    markUploading(id: string): void;
+    /** Mark a file as successfully uploaded. */
+    markDone(id: string): void;
+    /** Mark a file as failed, optionally attaching an error. */
+    markFailed(id: string, error?: unknown): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    private onNativeChange;
+    /**
+     * Start uploading every `pending` file. This is the code-driven trigger for
+     * `manual` mode, and what the "upload all" button calls in `confirm` mode.
+     *
+     * Returns a promise that resolves once every started file has settled — i.e.
+     * reached `done`, `failed`, or been cancelled/removed. It resolves with the
+     * same items handed to `(upload)`, so their final {@link NgnUploadFile.state}
+     * tells you which succeeded and which failed. Resolves with `[]` if there was
+     * nothing pending.
+     */
+    uploadAll(): Promise<NgnUploadFile[]>;
+    /**
+     * Start uploading a single `pending` file by its {@link NgnUploadFile.id}.
+     * Returns the same settle-promise as {@link uploadAll}.
+     */
+    uploadFile(id: string): Promise<NgnUploadFile[]>;
+    protected uploadOne(item: NgnUploadFile): void;
+    protected retryFile(item: NgnUploadFile): void;
+    protected removeFile(item: NgnUploadFile): void;
+    /** Human-readable file size for display in the list. */
+    protected formatSize(bytes: number): string;
+    /** Filter/trim dropped files to mirror the native input's own validation. */
+    private ingest;
+    private startUpload;
+    /** Resolve once the file (by id) leaves `uploading` — done/failed/cancelled. */
+    private whenSettled;
+    private settle;
+    private patch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnUpload, "ngn-upload", ["ngnUpload"], { "interaction": { "alias": "interaction"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "iconUpload": { "alias": "iconUpload"; "required": false; "isSignal": true; }; "confirmTrigger": { "alias": "confirmTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "listPosition": { "alias": "listPosition"; "required": false; "isSignal": true; }; }, { "upload": "upload"; "remove": "remove"; "retry": "retry"; "cancelUpload": "cancelUpload"; }, never, ["*"], true, never>;
+}
+
+export { NgnUpload };
+export type { NgnUploadConfirmTrigger, NgnUploadFile, NgnUploadFileState, NgnUploadInteraction, NgnUploadListPosition, NgnUploadMode };

package/types/ngneers-controls-utils-ng.d.ts

@@ -0,0 +1,129 @@
+import * as i0 from '@angular/core';
+import { Signal, ProviderToken, EffectRef, InputSignal, InputSignalWithTransform, Injector } from '@angular/core';
+import { NgnGlobalType } from '@ngneers/controls/utils';
+
+declare function classSignal(element: HTMLElement, klass: Signal<string | string[]>): void;
+
+/**
+ * Keeps keyboard focus inside a single container for the duration a modal
+ * overlay is open. On {@link activate} it remembers what was focused, moves
+ * focus into the container, and wraps `Tab`/`Shift+Tab` at the edges;
+ * {@link deactivate} tears the listener down and restores the prior focus.
+ *
+ * The container itself is focused as a fallback when it has no focusable
+ * children, so focus never escapes to the (inert) background.
+ */
+declare class FocusTrap {
+    private readonly container;
+    private _previouslyFocused;
+    private _active;
+    constructor(container: HTMLElement);
+    activate(): void;
+    deactivate(): void;
+    private readonly _onKeydown;
+}
+
+declare function generateElementId(): string;
+
+declare class NgnGlobal implements NgnGlobalType {
+    private readonly _window;
+    constructor();
+    get nextElementId(): number;
+    set nextElementId(value: number);
+    get fancyLogging(): boolean;
+    set fancyLogging(value: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgnGlobal, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgnGlobal>;
+}
+
+declare function injectOrThrow<T>(token: ProviderToken<T>, moduleName: string, errorMsg: string): T;
+
+/**
+ * An item managed by a {@link NotificationRegionController} — a single snackbar or
+ * toast. The controller drives focus and timer state through this narrow contract.
+ */
+interface NotificationRegionItem {
+    /** Move DOM focus to this item's root element. */
+    focus(): void;
+    /** Freeze the auto-hide timer because the region as a whole holds focus. */
+    regionPause(): void;
+    /** Release the region-level freeze; the item resumes unless still hovered/focused. */
+    regionResume(): void;
+}
+/**
+ * Keyboard-accessibility controller for a stack of transient notifications
+ * (snackbars / toasts) rendered inside a single host region.
+ *
+ * Implements the WAI-ARIA APG guidance for toasts: focus is never stolen when a
+ * notification appears, but a global hotkey (`F6`) lets the user jump into the
+ * region on demand. Within the region, a roving-tabindex model exposes exactly one
+ * item to the Tab sequence while `ArrowUp`/`ArrowDown`/`Home`/`End` move between
+ * items. Whenever the region holds focus, every timer in it is paused so nothing
+ * disappears mid-read.
+ *
+ * The host component owns the wiring: it forwards its events to the handlers here
+ * and binds {@link tabbableIndex} to each item's `tabindex`.
+ */
+declare class NotificationRegionController<T extends NotificationRegionItem> {
+    private readonly host;
+    private readonly items;
+    /** The item index currently exposed to the Tab sequence (roving tabindex). */
+    readonly activeIndex: i0.WritableSignal<number>;
+    private _regionFocused;
+    /**
+     * @param host  The region's root element, used to scope focus containment checks.
+     * @param items A getter returning the live, ordered list of items (oldest first).
+     */
+    constructor(host: HTMLElement, items: () => readonly T[]);
+    /**
+     * The roving tabindex target, clamped to the current item count so the region
+     * always has exactly one tabbable entry point even after items are removed.
+     */
+    tabbableIndex(): number;
+    /** Document-level handler: `F6` moves focus to the newest notification. */
+    handleGlobalKeydown(event: KeyboardEvent): void;
+    /** Region-level handler: arrow / Home / End roving between notifications. */
+    handleKeydown(event: KeyboardEvent): void;
+    /** Region gained focus (via hotkey, Tab, or click) — pause every timer in it. */
+    handleFocusIn(): void;
+    /** Region lost focus to something outside it — resume every timer. */
+    handleFocusOut(event: FocusEvent): void;
+    private focusIndex;
+}
+
+declare function signalWithPrevious<T>(signal: Signal<T>, previous?: T): Signal<{
+    current: T;
+    previous: T | undefined;
+}>;
+declare function computedWithPrevious<T>(computeFn: (prev?: T) => T, previous?: T): Signal<T>;
+declare function effectWithPrevious<T>(signal: Signal<T>, effectFn: (current: T, previous: T | undefined) => void): EffectRef;
+declare function explicitEffect<T extends readonly Signal<any>[]>(signals: [...T], effectFn: (values: {
+    [K in keyof T]: T[K] extends Signal<infer U> ? U : never;
+}) => void): EffectRef;
+declare function explicitAfterRenderEffect<T extends readonly Signal<any>[]>(signals: [...T], effectFn: (values: {
+    [K in keyof T]: T[K] extends Signal<infer U> ? U : never;
+}) => void): EffectRef;
+declare function asyncComputed<T>(computeFn: () => Promise<T>, initial: T): {
+    (): T;
+    isRunning: Signal<boolean>;
+    firstRunCompleted: Signal<boolean>;
+};
+declare function setInputSignalValue<T>(input: InputSignal<T> | InputSignalWithTransform<T, unknown>, value: T): void;
+declare function afterRenderComputed<T>(computeFn: () => T, defaultValue: T): () => T;
+declare function debounceSignal<T>(input: Signal<T>, delayMs: (() => number) | number): Signal<T>;
+
+type NgnStateStorage = 'local' | 'session';
+declare function loadState<T>(storage: NgnStateStorage, key: string): T | null;
+declare function saveState<T>(storage: NgnStateStorage, key: string, state: T | null): void;
+type RegisterStateOptions<T> = {
+    storage: () => NgnStateStorage;
+    key: () => string | null | undefined;
+    valueFn: (previousState: T | null) => T | null;
+    onLoad: (state: T | null) => T | null;
+    debounce?: number;
+    injector?: Injector;
+};
+declare function registerState<T>(options: RegisterStateOptions<T>): void;
+
+export { FocusTrap, NgnGlobal, NotificationRegionController, afterRenderComputed, asyncComputed, classSignal, computedWithPrevious, debounceSignal, effectWithPrevious, explicitAfterRenderEffect, explicitEffect, generateElementId, injectOrThrow, loadState, registerState, saveState, setInputSignalValue, signalWithPrevious };
+export type { NgnStateStorage, NotificationRegionItem, RegisterStateOptions };

package/types/ngneers-controls-utils.d.ts

@@ -0,0 +1,130 @@
+declare function toggleClass(element: HTMLElement, className: string | string[], state: boolean): void;
+
+declare function areObjectsDeepEqual<T extends object>(a: T, b: T): boolean;
+declare function areArraysDeepEqual<T>(a: readonly T[], b: readonly T[]): boolean;
+
+declare function throwExp(moduleName: string, errorMsg: string, ...additionalContext: unknown[]): never;
+declare class NgnError extends Error {
+    readonly additionalContext?: unknown[];
+    constructor(area: string, errorMsg: string, ...additionalContext: unknown[]);
+}
+
+declare function maybeCallback<T>(value: T | (() => T)): T;
+
+declare function fuzzyMatch(input: string, search: string): boolean;
+
+declare const globalPropertyName = "__ngn-controls-global__";
+interface NgnGlobalType {
+    nextElementId: number;
+    fancyLogging: boolean;
+}
+declare global {
+    interface Window {
+        [globalPropertyName]: NgnGlobalType;
+    }
+}
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare const Logger: {
+    logLevel: LogLevel;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+};
+
+declare function notNullish<T>(value: T | null | undefined): value is T;
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type SubKey<P, K> = [P] extends [never] ? K : P extends string ? K extends string ? `${P}.${K}` : K : K;
+type DeepPartial<T, Exclude extends string = never, P = never> = T extends object ? SubKey<P, '*'> extends Exclude ? T : Prettify<{
+    [K in keyof T as SubKey<P, K> extends Exclude ? never : K]?: DeepPartial<T[K], Exclude, SubKey<P, K>>;
+} & {
+    [K in keyof T as SubKey<P, K> extends Exclude ? K : never]: DeepPartial<T[K], Exclude, SubKey<P, K>>;
+}> : T;
+/**
+ * Returns all keys of a type T.
+ * If T is a union, returns all keys from all union members.
+ */
+type AllKeysOfUnion<T> = T extends any ? keyof T : never;
+/**
+ * Angular fills unspecified generic inputs with `any`.
+ * This replaces that `any` with a `Default` type, or returns `T` if `T` is not `any`.
+ */
+type InputGeneric<T, Default> = symbol extends T ? Default : T;
+
+declare function deepCopy<T>(obj: T): T extends ReadonlyArray<infer U> ? Array<U> : T;
+declare function objectKeys<T extends object>(obj: T): (keyof T)[];
+declare function objectEntries<T extends object>(obj: T): [keyof T, T[keyof T]][];
+declare function isObject(item: unknown): item is Record<string, unknown>;
+declare function deepMerge<T extends Record<string, unknown>, U extends Record<string, unknown>>(target: T, source: U): T & U;
+declare function getPropertyIfExists<T extends object, K extends AllKeysOfUnion<T>>(obj: T, key: K): T[K] | undefined;
+
+declare function getScrollTop(elementOffsetTop: number, elementHeight: number, containerHeight: number, currentScrollTop: number, behavior: ScrollLogicalPosition): number;
+
+/**
+ * Represents a time span that can be expressed in various formats:
+ * - As a number (milliseconds)
+ * - As a string in the format "XdXhXmXsXms" where each part is optional (e.g., "1d2h30m45s500ms" or "2h15m")
+ * - As an object with properties for days, hours, minutes, seconds, and milliseconds
+ * @example
+ * ```typescript
+ * // As a number
+ * const duration1: TimeSpan = 5000;
+ * // As a string
+ * const duration2: TimeSpan = "1d2h30m45s500ms";
+ * // As an object
+ * const duration3: TimeSpan = { days: 1, hours: 2, minutes: 30, seconds: 45, milliseconds: 500 };
+ * ```
+ */
+type TimeSpan = number | `${`${number}d` | ''}${`${number}h` | ''}${`${number}m` | ''}${`${number}s` | ''}${`${number}ms` | ''}` | {
+    /**
+     * Number of days in the time span.
+     */
+    days?: number;
+    /**
+     * Number of hours in the time span.
+     */
+    hours?: number;
+    /**
+     * Number of minutes in the time span.
+     */
+    minutes?: number;
+    /**
+     * Number of seconds in the time span.
+     */
+    seconds?: number;
+    /**
+     * Number of milliseconds in the time span.
+     */
+    milliseconds?: number;
+};
+/**
+ * Checks if the provided value is a valid TimeSpan.
+ * @param value The value to check.
+ * @returns `true` if the value is a valid TimeSpan, otherwise `false`.
+ */
+declare function isTimeSpan(value: unknown): value is TimeSpan;
+/**
+ * Converts a TimeSpan to milliseconds.
+ * @param timeSpan The TimeSpan to convert.
+ * @returns The equivalent time span in milliseconds.
+ */
+declare function getTimeSpanMilliseconds(timeSpan: TimeSpan): number;
+/**
+ * Converts a TimeSpan to a string representation.
+ * @param timeSpan The TimeSpan to convert.
+ * @returns A string representation of the time span.
+ */
+declare function getTimeSpanString(timeSpan: TimeSpan): string;
+/**
+ * Converts a TimeSpan to an object representation.
+ * @param timeSpan The TimeSpan to convert.
+ * @returns An object representation of the time span with properties for days, hours, minutes, seconds, and milliseconds.
+ */
+declare function getTimeSpan(timeSpan: TimeSpan): TimeSpan & object;
+
+export { Logger, NgnError, areArraysDeepEqual, areObjectsDeepEqual, deepCopy, deepMerge, fuzzyMatch, getPropertyIfExists, getScrollTop, getTimeSpan, getTimeSpanMilliseconds, getTimeSpanString, globalPropertyName, isObject, isTimeSpan, maybeCallback, notNullish, objectEntries, objectKeys, throwExp, toggleClass };
+export type { AllKeysOfUnion, DeepPartial, InputGeneric, LogLevel, NgnGlobalType, Prettify, TimeSpan };

package/types/ngneers-controls.d.ts

@@ -0,0 +1,2 @@
+
+export { };