@acorex/cdk 22.1.8 → 22.2.0-next.1

package/types/acorex-cdk-overlay.d.ts

@@ -4,6 +4,40 @@ import { AXZToken } from '@acorex/core/z-index';
 import * as i0 from '@angular/core';
 import { ElementRef, EmbeddedViewRef, ComponentRef } from '@angular/core';
 
+declare const AX_OVERLAY_DEFAULT_ENTER_ANIMATION: string[];
+declare const AX_OVERLAY_DEFAULT_LEAVE_ANIMATION: string[];
+type AXOverlayAnimation = boolean | string[] | {
+    enter?: string[];
+    leave?: string[];
+};
+interface AXOverlayResolvedAnimation {
+    enter: string[];
+    leave: string[];
+}
+/**
+ * Resolves overlay animation classes.
+ * - omitted: no animation (opt-in at the overlay layer)
+ * - `true`: default fade in/out
+ * - `false` or `[]`: no animation
+ * - `string[]`: custom enter classes only
+ * - `{ enter, leave }`: omitted keys fall back to the default fade classes
+ */
+declare function resolveOverlayAnimation(animation?: AXOverlayAnimation): AXOverlayResolvedAnimation;
+/** Prefers the content/pane so transforms are not applied to the full-screen container. */
+declare function getOverlayAnimationTarget(container: HTMLElement): HTMLElement;
+declare function applyOverlayAnimationClasses(element: HTMLElement, classes: string[]): void;
+declare function removeOverlayAnimationClasses(element: HTMLElement, classes: string[]): void;
+declare function prefersReducedMotion(documentRef: Document): boolean;
+declare function parseCssTimeList(value: string): number[];
+/** Maps theme duration utility classes to milliseconds (see tailwind-base). */
+declare function getAnimationDurationFromClasses(classes: string[]): number;
+declare function getOverlayAnimationTimeout(element: HTMLElement, documentRef: Document, fallbackMs?: number): number;
+declare function playOverlayLeaveAnimation(element: HTMLElement, enter: string[], leave: string[], documentRef: Document): Promise<void>;
+declare function waitForOverlayAnimationEnd(element: HTMLElement, documentRef: Document, options?: {
+    fallbackMs?: number;
+    animationName?: string;
+}): Promise<void>;
+
 type AXOverlayVisualContextScope = 'full' | 'theme';
 interface AXOverlayVisualContext {
     appearance?: string;
@@ -29,10 +63,12 @@ interface AXOverlayRef<T> {
     instance: EmbeddedViewRef<T> | ComponentRef<T>;
     /** Updates the overlay position relative to the anchor */
     updatePosition: () => void;
-    /** Destroys the overlay and removes it from the DOM */
+    /** Destroys the overlay. DOM removal waits for a leave animation when one is configured. */
     dispose: () => void;
     /** The overlay container element */
     overlayElement: HTMLElement | null;
+    /** The backdrop element if one was created */
+    backdropElement: HTMLElement | null;
     /** The z-index token for this overlay */
     zToken: AXZToken | null;
     /** Brings this overlay to the front of all other overlays */
@@ -62,12 +98,20 @@ interface AXOverlayOptions extends AXComponentOptions {
     anchorOptions?: AXOverlayAnchorOptions;
     /** Custom CSS class for the overlay panel */
     panelClass?: string | string[];
+    /**
+     * Enter/leave animation applied to overlay content (`.ax-overlay-content` or `.ax-overlay-pane`),
+     * not the full-screen container. Omitted: no animation. `true`: default fade in/out.
+     * `false` or `[]`: disabled. A class array is enter-only. `{ enter, leave }` configures both.
+     */
+    animation?: AXOverlayAnimation;
     /** Whether to close when clicking outside */
     closeOnOutsideClick?: boolean;
     /** Whether to close when pressing Escape */
     closeOnEscape?: boolean;
     /** Width of the overlay container (e.g., 'auto', '200px', '100%') */
     width?: string;
+    /** Dispose this overlay when Angular starts a navigation. Default: true. */
+    closeOnNavigation?: boolean;
     /** Callback when the overlay is disposed (e.g., due to scroll) */
     onDispose?: () => void;
     /** Whether to use centered container (default: true). Set to false for positioned overlays like toasts */
@@ -127,6 +171,7 @@ declare class AXOverlayService {
     private document;
     private zIndexService;
     private _platform;
+    private router;
     /**
      * Creates an overlay with optional anchor-based positioning.
      * @param content - Component or template to display
@@ -134,6 +179,17 @@ declare class AXOverlayService {
      * @returns Promise<AXOverlayRef> - Reference to the created overlay
      */
     create<T = unknown>(content: AXComponentContent<T>, options?: AXOverlayOptions): Promise<AXOverlayRef<T>>;
+    /**
+     * Mobile action sheets need a hit-testable scrim even when the caller did not
+     * ask for a backdrop. An explicit `backdrop.enabled: false` opts out.
+     */
+    private needsActionSheetBackdrop;
+    /**
+     * Fills in the action-sheet scrim when the caller did not configure a backdrop.
+     * Outside-click closing stays with the popover (`clickOut`); this layer only
+     * intercepts hits so the page behind the sheet cannot be clicked.
+     */
+    private withActionSheetBackdrop;
     /**
      * Creates a backdrop element.
      */
@@ -160,8 +216,8 @@ declare class AXOverlayService {
     private positionOverlay;
     private applyOverlayVisualContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXOverlayService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXOverlayService>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
-export { APPEARANCE_CLASSES, AXOverlayService, CONTRAST_CLASSES, MANAGED_OVERLAY_VISUAL_CLASSES, SIZE_CLASSES, THEME_CLASSES, applyVisualContext, calculateAnchorPosition, clampToViewport, findBestPosition, fitsInViewport, resolveContextElement, resolveVisualContext };
-export type { AXOverlayAnchorOptions, AXOverlayOptions, AXOverlayRef, AXOverlayVisualContext, AXOverlayVisualContextScope };
+export { APPEARANCE_CLASSES, AXOverlayService, AX_OVERLAY_DEFAULT_ENTER_ANIMATION, AX_OVERLAY_DEFAULT_LEAVE_ANIMATION, CONTRAST_CLASSES, MANAGED_OVERLAY_VISUAL_CLASSES, SIZE_CLASSES, THEME_CLASSES, applyOverlayAnimationClasses, applyVisualContext, calculateAnchorPosition, clampToViewport, findBestPosition, fitsInViewport, getAnimationDurationFromClasses, getOverlayAnimationTarget, getOverlayAnimationTimeout, parseCssTimeList, playOverlayLeaveAnimation, prefersReducedMotion, removeOverlayAnimationClasses, resolveContextElement, resolveOverlayAnimation, resolveVisualContext, waitForOverlayAnimationEnd };
+export type { AXOverlayAnchorOptions, AXOverlayAnimation, AXOverlayOptions, AXOverlayRef, AXOverlayResolvedAnimation, AXOverlayVisualContext, AXOverlayVisualContextScope };

package/types/acorex-cdk-resizable.d.ts

@@ -1,6 +1,26 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit, OnDestroy } from '@angular/core';
 
+type AXResizeHandle = 'start' | 'end' | 'top' | 'bottom' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+interface AXResizeSize {
+    width: number;
+    height: number;
+}
+/**
+ * Resize event payload. `value` / `oldValue` remain the host width so existing
+ * width-only listeners (`AXValueChangedEvent<number>`) keep compiling. Use `size`
+ * / `oldSize` when both axes matter.
+ */
+interface AXResizeChangedEvent {
+    component: unknown;
+    htmlElement?: HTMLElement;
+    isUserInteraction?: boolean;
+    name?: string;
+    value?: number;
+    oldValue?: number;
+    size: AXResizeSize;
+    oldSize: AXResizeSize;
+}
 declare class AXResizableDirective implements AfterViewInit, OnDestroy {
     private readonly el;
     private readonly platformService;
@@ -9,67 +29,89 @@ declare class AXResizableDirective implements AfterViewInit, OnDestroy {
     private readonly platformID;
     private readonly isBrowser;
     private hostElement;
-    private resizeHandle?;
-    private isResizing;
+    private readonly resizeHandles;
+    private readonly isResizing;
+    private activeHandle;
     private initialElementWidth;
-    private startMoveWidth;
-    private subscriptions;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    private readonly boundMouseEnter;
-    private readonly boundMouseLeave;
+    private initialElementHeight;
+    private startX;
+    private startY;
+    private startWidth;
+    private startHeight;
+    private startRatio;
+    private readonly subscriptions;
+    private resizeObserver?;
+    private readonly boundPointerDown;
+    private readonly boundPointerMove;
+    private readonly boundPointerUp;
+    private readonly boundPointerEnter;
+    private readonly boundPointerLeave;
     private readonly boundDoubleClick;
-    private readonly resizeObserver;
+    private readonly isRTL;
     /** Define if directive is active or not */
     axResizable: _angular_core.ModelSignal<boolean>;
+    /** Logical handles to render. Defaults to the inline-end edge. */
+    handles: _angular_core.ModelSignal<AXResizeHandle[]>;
     /** Minimum width for the resizable element. */
     minWidth: _angular_core.ModelSignal<number>;
     /** Maximum width for the resizable element. Defaults to parent width if not provided. */
     maxWidth: _angular_core.ModelSignal<number>;
-    /** Behavior on double-click: 'reset' or 'maximize'. */
+    /** Minimum height for the resizable element. */
+    minHeight: _angular_core.ModelSignal<number>;
+    /** Maximum height for the resizable element. Defaults to parent height if not provided. */
+    maxHeight: _angular_core.ModelSignal<number>;
+    /** Behavior on double-click: 'reset', 'maximize', or 'fit'. */
     dblClickAction: _angular_core.ModelSignal<"reset" | "maximize" | "fit">;
     /** Define initial width for the element. */
     width: _angular_core.ModelSignal<number>;
     /** Define reset width for the element. */
     defaultWidth: _angular_core.ModelSignal<number>;
+    /** Define initial height for the element. */
+    height: _angular_core.ModelSignal<number>;
+    /** Define reset height for the element. */
+    defaultHeight: _angular_core.ModelSignal<number>;
+    /** Lock the element's aspect ratio from the size captured at pointer-down. */
+    lockAspectRatio: _angular_core.ModelSignal<boolean>;
     /** Event emitted when resizing starts. */
-    onResizingStarted: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    onResizingStarted: _angular_core.OutputEmitterRef<AXResizeChangedEvent>;
     /** Event emitted when resizing ends. */
-    onResizingEnded: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    onResizingEnded: _angular_core.OutputEmitterRef<AXResizeChangedEvent>;
     /** Event emitted on double-click. */
-    onResizingDblClick: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    onResizingDblClick: _angular_core.OutputEmitterRef<AXResizeChangedEvent>;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    private setupResizableState;
-    private applyWidthFromModel;
-    private applyElementWidth;
-    private createResizeHandle;
+    private reconcileHandles;
+    private createHandle;
+    private attachHandleListeners;
+    private destroyHandle;
+    private destroyAllHandles;
     private applyHandleStyles;
-    private updateHandlePosition;
-    private attachEventListeners;
-    private cleanupEventListeners;
-    private isRTL;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
-    private onMouseEnter;
-    private onMouseLeave;
+    private updateAllHandlePositions;
+    private positionHandle;
+    private applyInlineSide;
+    private applySizeFromModel;
+    private applySize;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerEnter;
+    private onPointerLeave;
     private onDoubleClick;
-    private resetToInitialWidth;
-    private maximizeToMaxWidth;
+    private computeSize;
+    private clampSize;
+    private resetToInitialSize;
+    private maximizeToMaxSize;
     private fitToContent;
+    private getCurrentSize;
+    private createResizeEvent;
+    private getHandleType;
+    private getCursorForHandle;
+    private getActiveCursor;
+    private stopResizing;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXResizableDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXResizableDirective, "[axResizable]", never, { "axResizable": { "alias": "axResizable"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "dblClickAction": { "alias": "dblClickAction"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "defaultWidth": { "alias": "defaultWidth"; "required": false; "isSignal": true; }; }, { "axResizable": "axResizableChange"; "minWidth": "minWidthChange"; "maxWidth": "maxWidthChange"; "dblClickAction": "dblClickActionChange"; "width": "widthChange"; "defaultWidth": "defaultWidthChange"; "onResizingStarted": "onResizingStarted"; "onResizingEnded": "onResizingEnded"; "onResizingDblClick": "onResizingDblClick"; }, never, never, true, never>;
-}
-interface AXValueChangedEvent<T> {
-    component: unknown;
-    htmlElement?: HTMLElement;
-    isUserInteraction?: boolean;
-    name?: string;
-    value?: T;
-    oldValue?: T;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXResizableDirective, "[axResizable]", never, { "axResizable": { "alias": "axResizable"; "required": false; "isSignal": true; }; "handles": { "alias": "handles"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "dblClickAction": { "alias": "dblClickAction"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "defaultWidth": { "alias": "defaultWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "defaultHeight": { "alias": "defaultHeight"; "required": false; "isSignal": true; }; "lockAspectRatio": { "alias": "lockAspectRatio"; "required": false; "isSignal": true; }; }, { "axResizable": "axResizableChange"; "handles": "handlesChange"; "minWidth": "minWidthChange"; "maxWidth": "maxWidthChange"; "minHeight": "minHeightChange"; "maxHeight": "maxHeightChange"; "dblClickAction": "dblClickActionChange"; "width": "widthChange"; "defaultWidth": "defaultWidthChange"; "height": "heightChange"; "defaultHeight": "defaultHeightChange"; "lockAspectRatio": "lockAspectRatioChange"; "onResizingStarted": "onResizingStarted"; "onResizingEnded": "onResizingEnded"; "onResizingDblClick": "onResizingDblClick"; }, never, never, true, never>;
 }
 
 export { AXResizableDirective };
+export type { AXResizeChangedEvent, AXResizeHandle, AXResizeSize };

package/types/acorex-cdk-shimmer.d.ts

@@ -0,0 +1,68 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Applies the shimmer text effect to a host element.
+ */
+declare class AXShimmerDirective {
+    #private;
+    private readonly hostElement;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly refresh;
+    /**
+     * Plays the shimmer animation once instead of looping.
+     *
+     * @defaultValue false
+     */
+    once: _angular_core.InputSignal<boolean>;
+    /**
+     * Reverses the shimmer sweep direction.
+     *
+     * @defaultValue false
+     */
+    reverse: _angular_core.InputSignal<boolean>;
+    /**
+     * Disables the shimmer effect and renders normal text.
+     *
+     * @defaultValue false
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Duration of one shimmer sweep in milliseconds.
+     *
+     * @defaultValue 2000
+     */
+    duration: _angular_core.InputSignal<number>;
+    /**
+     * Width of the highlight band. Numbers use the spacing scale; strings accept any CSS length.
+     */
+    spread: _angular_core.InputSignal<string | number>;
+    /**
+     * Tilt of the highlight band in degrees.
+     *
+     * @defaultValue 20
+     */
+    angle: _angular_core.InputSignal<number>;
+    /**
+     * Explicit highlight color. Accepts ACoreX semantic colors (`primary`, `danger`, …) or any CSS color value.
+     * Falls back to a tint derived from currentColor when omitted.
+     */
+    color: _angular_core.InputSignal<string>;
+    constructor();
+    private get element();
+    private resolveSpread;
+    private isSemanticColor;
+    private resolveHighlightColor;
+    private isDarkMode;
+    private isRtl;
+    private prefersReducedMotion;
+    private buildBackgroundImage;
+    private applyShimmerStyles;
+    private clearShimmerStyles;
+    private restartShimmerAnimation;
+    private cancelShimmerAnimation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXShimmerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXShimmerDirective, "[axShimmer]", never, { "once": { "alias": "once"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "spread": { "alias": "spread"; "required": false; "isSignal": true; }; "angle": { "alias": "angle"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AXShimmerDirective };

package/types/acorex-cdk-text-editor.d.ts

@@ -0,0 +1,156 @@
+import * as _angular_core from '@angular/core';
+import * as _tiptap_core from '@tiptap/core';
+import { Content, Extensions, Editor, JSONContent } from '@tiptap/core';
+
+type AXTextEditorTiptapEditor = Editor;
+type AXTextEditorTiptapContent = Content;
+type AXTextEditorTiptapJSON = JSONContent;
+type AXTextEditorTiptapChain = ReturnType<Editor['chain']>;
+type AXTextEditorHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type AXTextEditorTextAlign = 'left' | 'center' | 'right' | 'justify';
+type AXTextEditorTextDirection = 'rtl' | 'ltr';
+type AXTextEditorFontSizeToken = 'small' | 'large' | 'huge';
+declare const AX_TEXT_EDITOR_FONT_SIZE_TOKEN_VALUES: Record<AXTextEditorFontSizeToken, string>;
+type AXTextEditorCommandAttrs = Record<string, unknown>;
+declare const AX_TEXT_EDITOR_ZOOM_PRESETS: readonly [40, 50, 75, 90, 100, 125, 150, 175, 200];
+declare const AX_TEXT_EDITOR_ZOOM_MIN = 40;
+declare const AX_TEXT_EDITOR_ZOOM_MAX = 200;
+declare const AX_TEXT_EDITOR_FONT_SIZES: readonly [8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48, 72];
+type AXTextEditorFontSize = (typeof AX_TEXT_EDITOR_FONT_SIZES)[number];
+declare const AX_TEXT_EDITOR_DEFAULT_TEXT_COLORS: string[];
+declare const AX_TEXT_EDITOR_DEFAULT_BACKGROUND_COLORS: string[];
+interface AXTextEditorRecentColor {
+    color: string;
+    kind: 'text' | 'background';
+}
+type AXTextEditorCommandType = 'undo' | 'redo' | 'bold' | 'italic' | 'underline' | 'strike' | 'heading' | 'paragraph' | 'align' | 'direction' | 'color' | 'highlight' | 'fontSize' | 'bulletList' | 'orderedList' | 'superscript' | 'subscript' | 'link' | 'unlink' | 'blockquote' | 'code' | 'codeBlock' | 'horizontalRule' | 'image' | 'video' | 'insertTable' | 'addColumnBefore' | 'addColumnAfter' | 'deleteColumn' | 'addRowBefore' | 'addRowAfter' | 'deleteRow' | 'toggleHeaderRow' | 'deleteTable';
+interface AXTextEditorFeatures {
+    table?: boolean;
+    image?: boolean;
+    video?: boolean;
+    superscript?: boolean;
+    subscript?: boolean;
+    keepSelection?: boolean;
+    placeholder?: boolean;
+}
+declare const AX_DEFAULT_TEXT_EDITOR_FEATURES: AXTextEditorFeatures;
+interface AXTextEditorLoadExtensionsOptions {
+    placeholder?: string | (() => string);
+    features?: AXTextEditorFeatures;
+    headingLevels?: AXTextEditorHeadingLevel[];
+    extensions?: Extensions;
+}
+interface AXTextEditorState {
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    code: boolean;
+    codeBlock: boolean;
+    headingLevel: AXTextEditorHeadingLevel | null;
+    bulletList: boolean;
+    orderedList: boolean;
+    blockquote: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    textAlign: AXTextEditorTextAlign | null;
+    textColor: string | null;
+    highlightColor: string | null;
+    linkHref: string | null;
+    fontSize: string | null;
+    textDirection: AXTextEditorTextDirection | null;
+    table: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    isEmpty: boolean;
+    isFocused: boolean;
+}
+declare const AX_EMPTY_TEXT_EDITOR_STATE: AXTextEditorState;
+interface AXTextEditorInitOptions {
+    content?: AXTextEditorTiptapContent;
+    editable?: boolean;
+    placeholder?: string | (() => string);
+    features?: AXTextEditorFeatures;
+    headingLevels?: AXTextEditorHeadingLevel[];
+    extensions?: Extensions;
+    editorProps?: _tiptap_core.EditorOptions['editorProps'];
+    /** @deprecated Use `editable: false` instead. */
+    readOnly?: boolean;
+    onUpdate?: (editor: AXTextEditorTiptapEditor) => void;
+    onFocus?: (editor: AXTextEditorTiptapEditor, event?: FocusEvent) => void;
+    onBlur?: (editor: AXTextEditorTiptapEditor, event?: FocusEvent) => void;
+    onSelectionUpdate?: (editor: AXTextEditorTiptapEditor) => void;
+    onTransaction?: (editor: AXTextEditorTiptapEditor) => void;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        superscript: {
+            toggleSuperscript: () => ReturnType;
+        };
+        subscript: {
+            toggleSubscript: () => ReturnType;
+        };
+        axTextEditorFontSize: {
+            setFontSize: (size: string | null) => ReturnType;
+        };
+        axTextEditorVideo: {
+            setVideo: (options: {
+                src: string;
+            }) => ReturnType;
+        };
+    }
+}
+
+declare class AXTextEditor {
+    readonly editor: _angular_core.WritableSignal<_tiptap_core.Editor>;
+    readonly state: _angular_core.WritableSignal<AXTextEditorState>;
+    readonly ready: _angular_core.WritableSignal<boolean>;
+    readonly version: _angular_core.WritableSignal<number>;
+    private readonly platformId;
+    private destroyed;
+    private applyingContent;
+    init(container: HTMLElement | string, options?: AXTextEditorInitOptions): Promise<void>;
+    destroy(): void;
+    refresh(): void;
+    setContent(value: AXTextEditorTiptapContent | null | undefined, emit?: boolean): void;
+    getHTML(): string;
+    getJSON(): AXTextEditorTiptapJSON | null;
+    getText(options?: {
+        blockSeparator?: string;
+    }): string;
+    isEmpty(): boolean;
+    isFocused(): boolean;
+    isEditable(): boolean;
+    setEditable(editable: boolean): void;
+    focus(): void;
+    blur(): void;
+    chain(): AXTextEditorTiptapChain | null;
+    get commands(): AXTextEditorTiptapEditor['commands'] | undefined;
+    isActive(command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+    can(command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+    run(command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+    private commandsApi;
+    private getCommandsApi;
+    insertContent(value: AXTextEditorTiptapContent): boolean;
+    clearContent(): boolean;
+    insertImage(src: string, alt?: string): void;
+    insertVideo(src: string): void;
+    setLink(href: string): void;
+    unsetLink(): void;
+    clearFormatting(): void;
+    toggleHeading(level: AXTextEditorHeadingLevel): void;
+    setTextAlign(align: AXTextEditorTextAlign): void;
+    setTextDirection(direction: AXTextEditorTextDirection): void;
+    private refreshState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTextEditor, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+declare function isTextEditorCommandActive(editor: AXTextEditorTiptapEditor, command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+declare function canRunTextEditorCommand(editor: AXTextEditorTiptapEditor, command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+declare function runTextEditorCommand(editor: AXTextEditorTiptapEditor, command: AXTextEditorCommandType, attrs?: AXTextEditorCommandAttrs): boolean;
+
+declare function createTextEditorExtensions(placeholderOrOptions?: string | (() => string) | AXTextEditorLoadExtensionsOptions): Promise<_tiptap_core.AnyExtension[]>;
+
+export { AXTextEditor, AX_DEFAULT_TEXT_EDITOR_FEATURES, AX_EMPTY_TEXT_EDITOR_STATE, AX_TEXT_EDITOR_DEFAULT_BACKGROUND_COLORS, AX_TEXT_EDITOR_DEFAULT_TEXT_COLORS, AX_TEXT_EDITOR_FONT_SIZES, AX_TEXT_EDITOR_FONT_SIZE_TOKEN_VALUES, AX_TEXT_EDITOR_ZOOM_MAX, AX_TEXT_EDITOR_ZOOM_MIN, AX_TEXT_EDITOR_ZOOM_PRESETS, canRunTextEditorCommand, createTextEditorExtensions, isTextEditorCommandActive, runTextEditorCommand };
+export type { AXTextEditorCommandAttrs, AXTextEditorCommandType, AXTextEditorFeatures, AXTextEditorFontSize, AXTextEditorFontSizeToken, AXTextEditorHeadingLevel, AXTextEditorInitOptions, AXTextEditorLoadExtensionsOptions, AXTextEditorRecentColor, AXTextEditorState, AXTextEditorTextAlign, AXTextEditorTextDirection, AXTextEditorTiptapChain, AXTextEditorTiptapContent, AXTextEditorTiptapEditor, AXTextEditorTiptapJSON };

package/types/acorex-cdk-uploader.d.ts

@@ -381,7 +381,7 @@ declare class AXUploaderService {
     private bindEvents;
     private applyFileTypeValidation;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXUploaderService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXUploaderService>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 export { AXUploadRequest, AXUploaderBrowseDirective, AXUploaderService, AXUploaderZoneDirective };

package/types/acorex-cdk-viewport-guard.d.ts

@@ -0,0 +1,99 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+type AXScreenOrientation = 'portrait' | 'landscape';
+/** Optional copy. Empty fields fall back to the translated defaults. */
+interface AXViewportGuardMessage {
+    kicker?: string | null;
+    title?: string | null;
+    message?: string | null;
+    hint?: string | null;
+}
+/** Resolved warning passed into a custom template as `let-message`. */
+interface AXViewportGuardTemplateData {
+    kind: 'size' | 'orientation';
+    orientation: AXScreenOrientation | null;
+    kicker: string;
+    title: string;
+    message: string;
+    hint: string;
+}
+/** Context of `axViewportGuardTemplate`. `$implicit` and `message` are the same data. */
+interface AXViewportGuardTemplateContext {
+    $implicit: AXViewportGuardTemplateData;
+    message: AXViewportGuardTemplateData;
+}
+
+/**
+ * Hides the host when the viewport is smaller than the given size.
+ *
+ * ```html
+ * <div axMinViewport="1024" [minHeight]="640" [message]="copy" [template]="warning"></div>
+ * ```
+ */
+declare class AXMinViewportDirective {
+    /** Minimum viewport width in CSS pixels. */
+    readonly minWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Minimum viewport height in CSS pixels. Omitted heights are ignored. */
+    readonly minHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Replaces any part of the default translated warning. */
+    readonly message: _angular_core.InputSignal<AXViewportGuardMessage>;
+    /** Custom warning. `let-message` receives the resolved copy. */
+    readonly template: _angular_core.InputSignal<TemplateRef<AXViewportGuardTemplateContext>>;
+    private readonly presenter;
+    private readonly projectedTemplate;
+    constructor();
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMinViewportDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXMinViewportDirective, "[axMinViewport]", ["axMinViewport"], { "minWidth": { "alias": "axMinViewport"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, ["projectedTemplate"], never, true, never>;
+}
+
+/**
+ * On a phone, hides the host when the device is not in the required orientation.
+ *
+ * ```html
+ * <div axOrientationLock="landscape" [message]="copy" [template]="warning"></div>
+ * ```
+ */
+declare class AXOrientationLockDirective {
+    /** Orientation that keeps the page visible. */
+    readonly orientation: _angular_core.InputSignal<AXScreenOrientation>;
+    /**
+     * Limits the guard to phones. Set to false to apply it on every device.
+     *
+     * @defaultValue true
+     */
+    readonly phonesOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Replaces any part of the default translated warning. */
+    readonly message: _angular_core.InputSignal<AXViewportGuardMessage>;
+    /** Custom warning. `let-message` receives the resolved copy. */
+    readonly template: _angular_core.InputSignal<TemplateRef<AXViewportGuardTemplateContext>>;
+    private readonly presenter;
+    private readonly projectedTemplate;
+    constructor();
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOrientationLockDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXOrientationLockDirective, "[axOrientationLock]", ["axOrientationLock"], { "orientation": { "alias": "axOrientationLock"; "required": true; "isSignal": true; }; "phonesOnly": { "alias": "phonesOnly"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, ["projectedTemplate"], never, true, never>;
+}
+
+/**
+ * Types an `ng-template` whose `let-message` is the resolved guard copy.
+ *
+ * ```html
+ * <ng-template #warning axViewportGuardTemplate let-message>
+ *   <h2>{{ message.title }}</h2>
+ *   <p>{{ message.message }}</p>
+ * </ng-template>
+ *
+ * <div axMinViewport="1024" [template]="warning"></div>
+ * ```
+ */
+declare class AXViewportGuardTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ngTemplateContextGuard(_directive: AXViewportGuardTemplateDirective, _context: unknown): _context is AXViewportGuardTemplateContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXViewportGuardTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXViewportGuardTemplateDirective, "ng-template[axViewportGuardTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+export { AXMinViewportDirective, AXOrientationLockDirective, AXViewportGuardTemplateDirective };
+export type { AXScreenOrientation, AXViewportGuardMessage, AXViewportGuardTemplateContext, AXViewportGuardTemplateData };