@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-command-bar.d.ts

@@ -0,0 +1,28 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+
+type CommandBarPosition = 'top' | 'bottom';
+
+declare class CommandBar {
+    private _elementRef;
+    private _renderer;
+    open: i0.InputSignalWithTransform<boolean, unknown>;
+    position: i0.InputSignal<CommandBarPosition>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBar, "ngs-command-bar", ["ngsCommandBar"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*", "ngs-command-bar-command,[ngs-command-bar-command],ngs-command-bar-divider"], true, never>;
+}
+
+declare class CommandBarDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarDivider, "ngs-command-bar-divider", ["ngsCommandBarDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class CommandBarCommand {
+    shortcut: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarCommand, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarCommand, "ngs-command-bar-command,[ngs-command-bar-command]", ["ngsCommandBarCommand"], { "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+export { CommandBar, CommandBarCommand, CommandBarDivider };
+export type { CommandBarPosition };

package/types/ngstarter-ui-components-comment-editor.d.ts

@@ -0,0 +1,194 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { Editor } from '@tiptap/core';
+import * as i1 from '@ngstarter-ui/components/upload';
+import { UploadFileSelectedEvent } from '@ngstarter-ui/components/upload';
+
+interface CommentEditorInterface {
+    api: CommentEditorAPI;
+}
+interface CommentEditorAPI {
+    isCommandDisabled: (command: string) => boolean | null;
+    isActive: (command: string) => boolean | null;
+    runCommand: (command: string) => void;
+    editor: () => Editor;
+    isToolbarActive: () => boolean;
+    toggleToolbar: () => void;
+    isEditorActivated: () => boolean;
+}
+declare const COMMENT_EDITOR: InjectionToken<unknown>;
+declare const COMMENT_EDITOR_BUBBLE_MENU: InjectionToken<unknown>;
+
+declare class CommentEditor implements OnInit, OnDestroy {
+    private _platformId;
+    private _document;
+    private _cdr;
+    private _injector;
+    private _content;
+    private _bubbleMenu;
+    private _imageBubbleMenu;
+    protected _value: string;
+    protected editor: Editor;
+    protected showToolbar: boolean;
+    protected fullView: boolean;
+    contentMaxHeight: i0.InputSignal<number | undefined>;
+    buttonCancelLabel: i0.InputSignal<string>;
+    buttonSendLabel: i0.InputSignal<string>;
+    placeholder: i0.InputSignal<string>;
+    toolbarAlwaysVisible: i0.InputSignalWithTransform<boolean, unknown>;
+    fullViewMode: i0.InputSignalWithTransform<boolean, unknown>;
+    cancelButtonAlwaysVisible: i0.InputSignalWithTransform<boolean, unknown>;
+    imageUploadFn: i0.InputSignal<((file: Blob) => Promise<string>) | undefined>;
+    readonly sent: i0.OutputEmitterRef<string>;
+    readonly canceled: i0.OutputEmitterRef<void>;
+    ngOnInit(): void;
+    get api(): CommentEditorAPI;
+    isCommandDisabled(command: string): boolean | null;
+    ngOnDestroy(): void;
+    send(event: MouseEvent): void;
+    activateFullView(): void;
+    toggleToolbar(): void;
+    cancel(event: MouseEvent): void;
+    private _runCommand;
+    private _init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditor, "ngs-comment-editor", ["ngsCommentEditor"], { "contentMaxHeight": { "alias": "contentMaxHeight"; "required": false; "isSignal": true; }; "buttonCancelLabel": { "alias": "buttonCancelLabel"; "required": false; "isSignal": true; }; "buttonSendLabel": { "alias": "buttonSendLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "toolbarAlwaysVisible": { "alias": "toolbarAlwaysVisible"; "required": false; "isSignal": true; }; "fullViewMode": { "alias": "fullViewMode"; "required": false; "isSignal": true; }; "cancelButtonAlwaysVisible": { "alias": "cancelButtonAlwaysVisible"; "required": false; "isSignal": true; }; "imageUploadFn": { "alias": "imageUploadFn"; "required": false; "isSignal": true; }; }, { "sent": "sent"; "canceled": "canceled"; }, never, ["ngs-comment-editor-toolbar", "ngs-comment-editor-footer-bar", "ngs-comment-editor-bubble-menu"], true, never>;
+}
+
+declare class CommentEditorDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorDivider, "ngs-comment-editor-divider", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorToolbar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorToolbar, "ngs-comment-editor-toolbar", ["ngsCommentEditorToolbar"], {}, {}, never, ["[ngsCommentEditorCommand],ngs-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorBubbleMenu {
+    protected commentEditor: CommentEditorInterface;
+    getLinkUrl(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorBubbleMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorBubbleMenu, "ngs-comment-editor-bubble-menu", ["ngsCommentEditorBubbleMenu"], {}, {}, never, ["[ngsCommentEditorCommandEditLink],[ngsCommentEditorCommandUnsetLink]", "[ngsCommentEditorCommand],ngs-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorFooterBar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorFooterBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorFooterBar, "ngs-comment-editor-footer-bar", ["ngsCommentEditorFooterBar"], {}, {}, never, ["[ngsCommentEditorCommand],ngs-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorCommandDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandDirective, "[ngsCommentEditorCommand]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBoldDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBoldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBoldDirective, "[ngsCommentEditorCommandBold]", ["ngsCommentEditorCommandBold"], {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandItalicDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandItalicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandItalicDirective, "[ngsCommentEditorCommandItalic]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandStrikeDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandStrikeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandStrikeDirective, "[ngsCommentEditorCommandStrike]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBulletListDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBulletListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBulletListDirective, "[ngsCommentEditorCommandBulletList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandOrderedListDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandOrderedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandOrderedListDirective, "[ngsCommentEditorCommandOrderedList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBlockquoteDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBlockquoteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBlockquoteDirective, "[ngsCommentEditorCommandBlockquote]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandCodeBlockDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandCodeBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandCodeBlockDirective, "[ngsCommentEditorCommandCodeBlock]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandImageDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onImageSelected(event: UploadFileSelectedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandImageDirective, "[ngsCommentEditorCommandImage]", never, {}, {}, never, never, true, [{ directive: typeof i1.UploadTriggerDirective; inputs: {}; outputs: { "fileSelected": "fileSelected"; }; }]>;
+}
+
+declare class CommentEditorCommandYoutubeDirective {
+    protected commentEditor: CommentEditorInterface;
+    private _dialog;
+    private _destroyRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandYoutubeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandYoutubeDirective, "[ngsCommentEditorCommandYoutube]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected commentEditor: CommentEditorInterface;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandLinkDirective, "[ngsCommentEditorCommandLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandCodeDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandCodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandCodeDirective, "[ngsCommentEditorCommandCode]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandEditLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected commentEditor: CommentEditorInterface;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandEditLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandEditLinkDirective, "[ngsCommentEditorCommandEditLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandUnsetLinkDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandUnsetLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandUnsetLinkDirective, "[ngsCommentEditorCommandUnsetLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandToggleToolbarDirective {
+    protected commentEditor: CommentEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandToggleToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandToggleToolbarDirective, "[ngsCommentEditorCommandToggleToolbar]", never, {}, {}, never, never, true, never>;
+}
+
+export { COMMENT_EDITOR, COMMENT_EDITOR_BUBBLE_MENU, CommentEditor, CommentEditorBubbleMenu, CommentEditorCommandBlockquoteDirective, CommentEditorCommandBoldDirective, CommentEditorCommandBulletListDirective, CommentEditorCommandCodeBlockDirective, CommentEditorCommandCodeDirective, CommentEditorCommandDirective, CommentEditorCommandEditLinkDirective, CommentEditorCommandImageDirective, CommentEditorCommandItalicDirective, CommentEditorCommandLinkDirective, CommentEditorCommandOrderedListDirective, CommentEditorCommandStrikeDirective, CommentEditorCommandToggleToolbarDirective, CommentEditorCommandUnsetLinkDirective, CommentEditorCommandYoutubeDirective, CommentEditorDivider, CommentEditorFooterBar, CommentEditorToolbar };
+export type { CommentEditorAPI, CommentEditorInterface };

package/types/ngstarter-ui-components-comparison-slider.d.ts

@@ -0,0 +1,42 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+
+declare class ComparisonSlider implements AfterViewInit, OnDestroy {
+    private resizeObserver;
+    private platformId;
+    private ngZone;
+    private destroyRef;
+    private sliderContainerRef;
+    private handleRef;
+    initialPosition: i0.InputSignal<number>;
+    sliderPosition: i0.WritableSignal<number>;
+    isDragging: i0.WritableSignal<boolean>;
+    private containerRect;
+    handleLeftStyle: i0.Signal<string>;
+    afterImageClipStyle: i0.Signal<string>;
+    private isBrowser;
+    constructor();
+    ngAfterViewInit(): void;
+    private initDragStreams;
+    ngOnDestroy(): void;
+    private updateContainerRect;
+    private updateSliderPosition;
+    protected onContextMenu(event: MouseEvent): void;
+    protected onDragStart(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComparisonSlider, "ngs-comparison-slider", ["ngsComparisonSlider"], { "initialPosition": { "alias": "initialPosition"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsComparisonSliderBeforeImage]", "[ngsComparisonSliderAfterImage]"], true, never>;
+}
+
+declare class ComparisonSliderAfterImageDirective {
+    protected onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSliderAfterImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComparisonSliderAfterImageDirective, "[ngsComparisonSliderAfterImage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ComparisonSliderBeforeImageDirective {
+    protected onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSliderBeforeImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComparisonSliderBeforeImageDirective, "[ngsComparisonSliderBeforeImage]", never, {}, {}, never, never, true, never>;
+}
+
+export { ComparisonSlider, ComparisonSliderAfterImageDirective, ComparisonSliderBeforeImageDirective };

package/types/ngstarter-ui-components-confirm.d.ts

@@ -0,0 +1,34 @@
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+interface ConfirmOptions {
+    title: string;
+    description: string;
+}
+
+declare class ConfirmRef {
+    readonly canceled: EventEmitter<any>;
+    readonly confirmed: EventEmitter<any>;
+    readonly closed: EventEmitter<any>;
+    close(): void;
+    cancel(): void;
+    confirm(): void;
+}
+
+declare class ConfirmManager {
+    private _dialog;
+    private _destroyRef;
+    open(options: ConfirmOptions): ConfirmRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmManager>;
+}
+
+declare class Confirm {
+    private _data;
+    title: i0.WritableSignal<any>;
+    description: i0.WritableSignal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Confirm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Confirm, "ngs-confirm", ["ngsConfirm"], {}, {}, never, never, true, never>;
+}
+
+export { Confirm, ConfirmManager, ConfirmRef };

package/types/ngstarter-ui-components-content-editor.d.ts

@@ -0,0 +1,321 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, OnInit, OnDestroy, AfterViewInit, EventEmitter, Type, ViewContainerRef, ElementRef, Renderer2, NgZone } from '@angular/core';
+import { CdkDragDrop, CdkDragStart } from '@angular/cdk/drag-drop';
+import { Menu, MenuCloseReason } from '@ngstarter-ui/components/menu';
+import { Popover } from '@ngstarter-ui/components/popover';
+import { Observable } from 'rxjs';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Overlay, OverlayContainer } from '@angular/cdk/overlay';
+
+type TextAlignment = 'left' | 'center' | 'right' | 'justify' | 'start' | 'end' | '' | null;
+
+declare const CONTENT_BUILDER: InjectionToken<unknown>;
+declare const CONTENT_EDITOR_BLOCK: InjectionToken<readonly ContentEditorDataBlock[]>;
+interface ContentEditorDataBlock {
+    id: Signal<string>;
+    getData(): any;
+    focus(): void;
+    isEmpty(): boolean;
+    initialized: Signal<boolean>;
+}
+interface ContentEditorBlockEmpty {
+    content: any;
+    settings: {
+        [prop: string]: any;
+    };
+}
+interface ContentEditorBlock {
+    id: string;
+    type: string;
+    content: any;
+    isEmpty: boolean;
+    props?: ContentEditorItemProperty[];
+    settings: any;
+}
+interface ContentEditorBlockDef {
+    component: () => any;
+    type: string;
+    empty: () => ContentEditorBlockEmpty;
+    options: {
+        [prop: string]: any;
+    };
+}
+interface ContentEditorHeadingBlockSettings {
+    level: number;
+}
+interface ContentEditorSuggestionHeading {
+    type: 'item' | 'heading';
+    title: string;
+}
+interface ContentEditorSuggestionItem {
+    type: 'item' | 'heading';
+    title: string;
+    description: string;
+    iconName: string;
+    hotKeys: string;
+    blockType: string;
+    blockOptions: object;
+}
+interface ContentEditorImageContent {
+    src: string;
+    alt: string;
+    [prop: string]: any;
+}
+interface ContentEditorVideoContent {
+    src: string;
+    caption: string;
+    orientation?: 'portrait' | 'landscape';
+    [prop: string]: any;
+}
+interface ContentEditorEmbedContent {
+    url: string;
+    type: string;
+}
+interface ContentEditorImageBlockSettings {
+    width?: number;
+    height?: number;
+    actualWidth?: number;
+    actualHeight?: number;
+}
+interface ContentEditorVideoBlockSettings {
+    width?: number;
+    height?: number;
+    actualWidth?: number;
+    actualHeight?: number;
+}
+interface ContentEditorEmbedBlockSettings {
+    width: number | null;
+    height: number | null;
+}
+interface ContentEditorListItem {
+    content: string;
+    props?: ContentEditorItemProperty[];
+    children: ContentEditorListItem[];
+    [prop: string]: any;
+}
+interface ContentEditorListSettings {
+    listStyle: string;
+}
+interface ContentEditorItemProperty {
+    name: string;
+    value: string;
+}
+interface ContentEditorTableBlockSettings {
+}
+interface ContentEditorOptions {
+    [prop: string]: any;
+}
+
+declare class CommandBarComponent implements OnInit, OnDestroy {
+    private _document;
+    private _textHighlightService;
+    private _renderer;
+    private _dialog;
+    observedElement: HTMLElement | null;
+    props: _angular_core.WritableSignal<ContentEditorItemProperty[]>;
+    alignment: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    toggleBold(): void;
+    toggleItalic(): void;
+    toggleCode(): void;
+    toggleStrike(): void;
+    toggleUnderline(): void;
+    toggleSuperscript(): void;
+    toggleSubscript(): void;
+    isLinkActive(): boolean;
+    isActive(tagName: string): boolean;
+    setTextAlignment(alignment: TextAlignment): void;
+    isTextAlignment(alignment: TextAlignment): boolean;
+    addLink(): void;
+    editLink(): void;
+    protected onMenuOpen(): void;
+    protected onMenuClose(): void;
+    protected preventMenuClose(event: MouseEvent): void;
+    protected onTextColorChanged(color: string): void;
+    protected onBackgroundColorChanged(color: string): void;
+    private _extractProps;
+    ngOnDestroy(): void;
+    private _unwrapTextSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandBarComponent, "ngs-command-bar", never, { "observedElement": { "alias": "observedElement"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to enable mouse-drag selection of child blocks inside a container.
+ *
+ * Behavior:
+ * - Drag can be started only from an area that is NOT inside a block (matched by `blockSelector`).
+ * - While dragging, the directive creates a dynamic selection rectangle element with the
+ *   class `selectionAreaClass` (default: `ngs-textContent-builder-selection-area`).
+ * - Any block that intersects the selection rectangle receives `selectedClass` (default: `is-selected`).
+ *   When the block leaves the selection area, the class is removed.
+ */
+declare class BlockSelectionDirective implements OnDestroy {
+    private document;
+    private _platformId;
+    private contentBuilder;
+    /** CSS selector for selectable blocks. Defaults to `.block`. */
+    blockSelector: _angular_core.InputSignal<string>;
+    autoScrollContainerSelector: _angular_core.InputSignal<string | null>;
+    /** CSS class applied to the dynamic selection rectangle element. */
+    selectionAreaClass: _angular_core.InputSignal<string>;
+    /**
+     * List of CSS class names to ignore when starting selection.
+     * If the mousedown target or any of its ancestors (via closest) contains any of
+     * these classes, the selection will NOT start. Class names can be provided with
+     * or without leading dot (e.g., 'toolbar-button' or '.toolbar-button').
+     */
+    ignoreClasses: _angular_core.InputSignal<string[]>;
+    private elRef;
+    private host;
+    private selection;
+    private selectedSet;
+    constructor();
+    ngOnDestroy(): void;
+    private isInIgnoredArea;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockSelectionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BlockSelectionDirective, "[ngsBlockSelection]", never, { "blockSelector": { "alias": "blockSelector"; "required": false; "isSignal": true; }; "autoScrollContainerSelector": { "alias": "autoScrollContainerSelector"; "required": false; "isSignal": true; }; "selectionAreaClass": { "alias": "selectionAreaClass"; "required": false; "isSignal": true; }; "ignoreClasses": { "alias": "ignoreClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ContentBuilderComponent implements OnInit, AfterViewInit, OnDestroy {
+    private _platformId;
+    private _store;
+    private elRef;
+    private envInjector;
+    private cdr;
+    private confirmManager;
+    private _resolvedScrollContainer;
+    private _scrollEffect?;
+    private _scrollSubject;
+    private _scrollBindSub;
+    private _scroll$;
+    get scrollContainerScrolled(): Observable<number>;
+    private blockDefs;
+    content: _angular_core.InputSignal<ContentEditorBlock[]>;
+    contentChangedDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    suggestions: _angular_core.InputSignal<any>;
+    options: _angular_core.InputSignal<ContentEditorOptions>;
+    scrollContainer: _angular_core.InputSignal<string | undefined>;
+    readonly contentChanged: _angular_core.OutputEmitterRef<ContentEditorBlock[]>;
+    readonly focusChanged: EventEmitter<void>;
+    protected _content: _angular_core.WritableSignal<ContentEditorBlock[]>;
+    protected blockDefsMap: Map<string, any>;
+    protected blockDefsOptionsMap: Map<string, any>;
+    protected _blockDragging: _angular_core.WritableSignal<boolean>;
+    isSelectionOfBlocksActive: _angular_core.WritableSignal<boolean>;
+    _oldContent: _angular_core.WritableSignal<{}>;
+    readonly selectedBlocksModel: SelectionModel<unknown>;
+    commandBar: typeof CommandBarComponent;
+    get api(): {
+        focusChanged: EventEmitter<void>;
+    };
+    private buildBlockDefMaps;
+    getBlockDefOption(type: string, key: string): any;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Public accessor for the resolved scroll container. If not computed yet, it will compute now.
+     */
+    getScrollContainer(): Element | Window;
+    /**
+     * Resolves the scroll container element according to the following rules:
+     * - If `scrollContainer` input is provided, uses `closest(selector)` starting from the host element.
+     * - If not provided or `closest` returned null, automatically finds the first scrollable parent by walking up the DOM.
+     * - Fallback to `document.scrollingElement` or `window` if nothing suitable found.
+     */
+    private _computeScrollContainer;
+    private _isElementScrollable;
+    private _rebindScrollListener;
+    appendBlock(type: string, focus?: boolean): void;
+    insertBlock(type: string, index: number, options?: object, focus?: boolean, content?: any): any;
+    private _createBlock;
+    addBlock(type: string, options: object, index?: number): void;
+    duplicateBlock(blockId: string): void;
+    duplicateSelectedBlocks(popover: Popover): void;
+    deleteBlock(blockId: string): void;
+    setBlockProps(id: string, props: ContentEditorItemProperty[]): void;
+    insertEmptyBlock(index: number): void;
+    focusBlock(id: string | null): void;
+    isBlockFocused(id: string): boolean;
+    isActiveBlock(id: string): boolean;
+    drop(event: CdkDragDrop<ContentEditorBlock[]>): void;
+    onTagSelected(tagName: string | null): void;
+    getData(): ContentEditorBlock[];
+    emitContentChangeEvent(): void;
+    selectBlock(blockId: string, multiple?: boolean): void;
+    unselectBlock(blockId: string): void;
+    unselectSelectedBlocks(): void;
+    isBlockSelected(blockId: string): boolean;
+    deleteSelectedBlocks(popover?: Popover): void;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    protected onDragStarted(event: CdkDragStart, block: ContentEditorBlock): void;
+    protected onDragEnded(event: CdkDragStart, block: ContentEditorBlock): void;
+    protected addBlockFromSuggestionMenu(suggestionsMenu: Menu, type: string, options: object): void;
+    protected preventMenuClose(event: Event): void;
+    protected setActiveBlockId(event: Event, id: string | null): void;
+    protected onFocusChange(origin: string | null, dataBlock: ContentEditorBlock): void;
+    protected onSuggestionsMenuOpen(): void;
+    protected onSuggestionsMenuClose(reason: MenuCloseReason): void;
+    ngOnDestroy(): void;
+    onSettingsPopoverClose(): void;
+    protected _onPaste(event: ClipboardEvent): void;
+    private _handleTextPaste;
+    private _handleHtmlPaste;
+    private _mapNodeToBlock;
+    private _mapListItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentBuilderComponent, "ngs-content-builder", ["ngsContentBuilder"], { "content": { "alias": "content"; "required": false; "isSignal": true; }; "contentChangedDelay": { "alias": "contentChangedDelay"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "scrollContainer": { "alias": "scrollContainer"; "required": false; "isSignal": true; }; }, { "contentChanged": "contentChanged"; }, never, never, true, [{ directive: typeof BlockSelectionDirective; inputs: { "autoScrollContainerSelector": "autoScrollContainerSelector"; }; outputs: {}; }]>;
+}
+
+declare class ContentViewerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentViewerComponent, "ngs-content-viewer", never, {}, {}, never, never, true, never>;
+}
+
+interface ISelectionPopupComponent {
+    observedElement?: HTMLElement | null;
+}
+declare class TextSelectionPopupDirective implements OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    private elementRef;
+    private renderer;
+    private overlayContainer;
+    private ngZone;
+    targetComponent: Type<ISelectionPopupComponent>;
+    closestContentObserverClass: string | null;
+    tagSelected: EventEmitter<string | null>;
+    private overlayRef;
+    private hostElement;
+    private currentSelectionRange;
+    private documentClickListener;
+    private positionStrategy;
+    private scrollListener;
+    private scrollSubject;
+    private scrollSubscription;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elementRef: ElementRef<HTMLElement>, renderer: Renderer2, overlayContainer: OverlayContainer, ngZone: NgZone);
+    onDocumentClickHostListener(event: MouseEvent): void;
+    onDocumentKeyDown(event: KeyboardEvent): void;
+    private processSelection;
+    private showPopup;
+    private closePopupIfNeeded;
+    private closePopup;
+    private addScrollListener;
+    private removeScrollListener;
+    private updatePopupPositionOnScroll;
+    private findClosestElementWithClass;
+    private getContainingTagName;
+    private addDocumentClickListener;
+    private removeDocumentClickListener;
+    private handleDocumentClick;
+    private isEventInsidePopup;
+    private isClickInsidePopup;
+    private isFocusInsidePopup;
+    private areRangesEqual;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextSelectionPopupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextSelectionPopupDirective, "[ngsTextSelectionPopup]", never, { "targetComponent": { "alias": "targetComponent"; "required": false; }; "closestContentObserverClass": { "alias": "closestContentObserverClass"; "required": false; }; }, { "tagSelected": "tagSelected"; }, never, never, true, never>;
+}
+
+export { BlockSelectionDirective, CONTENT_BUILDER, CONTENT_EDITOR_BLOCK, CommandBarComponent, ContentBuilderComponent, ContentViewerComponent, TextSelectionPopupDirective };
+export type { ContentEditorBlock, ContentEditorBlockDef, ContentEditorBlockEmpty, ContentEditorDataBlock, ContentEditorEmbedBlockSettings, ContentEditorEmbedContent, ContentEditorHeadingBlockSettings, ContentEditorImageBlockSettings, ContentEditorImageContent, ContentEditorItemProperty, ContentEditorListItem, ContentEditorListSettings, ContentEditorOptions, ContentEditorSuggestionHeading, ContentEditorSuggestionItem, ContentEditorTableBlockSettings, ContentEditorVideoBlockSettings, ContentEditorVideoContent, ISelectionPopupComponent };

package/types/ngstarter-ui-components-content-fade.d.ts

@@ -0,0 +1,17 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, SimpleChanges } from '@angular/core';
+
+type ContentFadePosition = 'both' | 'start' | 'end';
+
+declare class ContentFade implements OnChanges {
+    private _elementRef;
+    color: _angular_core.InputSignal<unknown>;
+    width: _angular_core.InputSignal<unknown>;
+    position: _angular_core.InputSignal<ContentFadePosition>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentFade, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentFade, "ngs-content-fade", ["ngsContentFade"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ContentFade };
+export type { ContentFadePosition };