@f1falcha/stimulus 1.0.0

package/esm2022/taglist/tag/tag.directive.mjs

@@ -0,0 +1,30 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { NbTagInputDirective } from '@nebular/theme';
+import * as i0 from "@angular/core";
+import * as i1 from "@nebular/theme";
+class SclTagInput extends NbTagInputDirective {
+    constructor(hostElement, focusMonitor, renderer, zone, statusService) {
+        super(hostElement, focusMonitor, renderer, zone, statusService);
+        this.tagAdd = new EventEmitter();
+        this.setAttribute();
+    }
+    setAttribute() {
+        this.renderer.setAttribute(this._hostElement.nativeElement, 'nbTagInput', '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTagInput, deps: [{ token: i0.ElementRef }, { token: i1.NbFocusMonitor }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i1.NbStatusService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: SclTagInput, isStandalone: true, selector: "input[sclTagInput]", inputs: { separatorKeys: "separatorKeys" }, outputs: { tagAdd: "tagAdd" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true }); }
+}
+export { SclTagInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTagInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'input[sclTagInput]',
+                    template: `<ng-content></ng-content>`,
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NbFocusMonitor }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i1.NbStatusService }]; }, propDecorators: { separatorKeys: [{
+                type: Input
+            }], tagAdd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/taglist/taglist.component.mjs

@@ -0,0 +1,39 @@
+import { CommonModule } from '@angular/common';
+import { Component, ContentChildren, EventEmitter, Output } from '@angular/core';
+import { SclTagComponent } from './tag/tag.component';
+import * as i0 from "@angular/core";
+class SclTagListComponent {
+    constructor() {
+        this.tagRemove = new EventEmitter();
+    }
+    ngAfterContentInit() {
+        this.handleTagRemove();
+        this.tags.changes.subscribe(() => this.handleTagRemove());
+    }
+    handleTagRemove() {
+        this.tags.forEach(tag => {
+            tag.remove.pipe().subscribe(() => this.tagRemove.emit(tag));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTagListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: SclTagListComponent, isStandalone: true, selector: "scl-tag-list", outputs: { tagRemove: "tagRemove" }, host: { classAttribute: "scl-tag-list " }, queries: [{ propertyName: "tags", predicate: SclTagComponent, descendants: true }], ngImport: i0, template: ` <ng-content></ng-content> `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] }); }
+}
+export { SclTagListComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTagListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'scl-tag-list',
+                    standalone: true,
+                    imports: [CommonModule],
+                    host: {
+                        class: 'scl-tag-list ',
+                    },
+                    template: ` <ng-content></ng-content> `,
+                }]
+        }], propDecorators: { tags: [{
+                type: ContentChildren,
+                args: [SclTagComponent, { descendants: true }]
+            }], tagRemove: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/text-decoration/text-decoration.component.mjs

@@ -0,0 +1,26 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+class SclTextDecoration {
+    get none() {
+        return this.type === 'none';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTextDecoration, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: SclTextDecoration, isStandalone: true, selector: "[sclTextDecoration]", inputs: { type: "type" }, host: { properties: { "class.scl-text-decoration--none": "this.none" }, classAttribute: "scl-text-decoration" }, ngImport: i0 }); }
+}
+export { SclTextDecoration };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTextDecoration, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sclTextDecoration]',
+                    standalone: true,
+                    host: {
+                        class: 'scl-text-decoration',
+                    },
+                }]
+        }], propDecorators: { type: [{
+                type: Input
+            }], none: [{
+                type: HostBinding,
+                args: ['class.scl-text-decoration--none']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC1kZWNvcmF0aW9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wYWNrYWdlcy90ZXh0LWRlY29yYXRpb24vdGV4dC1kZWNvcmF0aW9uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRzlELE1BT2EsaUJBQWlCO0lBRzFCLElBQ0ksSUFBSTtRQUNKLE9BQU8sSUFBSSxDQUFDLElBQUksS0FBSyxNQUFNLENBQUM7SUFDaEMsQ0FBQzs4R0FOUSxpQkFBaUI7a0dBQWpCLGlCQUFpQjs7U0FBakIsaUJBQWlCOzJGQUFqQixpQkFBaUI7a0JBUDdCLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHFCQUFxQjtvQkFDL0IsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLElBQUksRUFBRTt3QkFDRixLQUFLLEVBQUUscUJBQXFCO3FCQUMvQjtpQkFDSjs4QkFFWSxJQUFJO3NCQUFaLEtBQUs7Z0JBR0YsSUFBSTtzQkFEUCxXQUFXO3VCQUFDLGlDQUFpQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdEJpbmRpbmcsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5leHBvcnQgdHlwZSBUZXh0RGVjb3JhdGlvbiA9ICdub25lJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbc2NsVGV4dERlY29yYXRpb25dJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgY2xhc3M6ICdzY2wtdGV4dC1kZWNvcmF0aW9uJyxcbiAgICB9LFxufSlcbmV4cG9ydCBjbGFzcyBTY2xUZXh0RGVjb3JhdGlvbiB7XG4gICAgQElucHV0KCkgdHlwZT86IFRleHREZWNvcmF0aW9uO1xuXG4gICAgQEhvc3RCaW5kaW5nKCdjbGFzcy5zY2wtdGV4dC1kZWNvcmF0aW9uLS1ub25lJylcbiAgICBnZXQgbm9uZSgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMudHlwZSA9PT0gJ25vbmUnO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/text-editor/text-editor.mjs

@@ -0,0 +1,263 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { CommonModule } from '@angular/common';
+import { Component, Input, ViewChild, forwardRef } from '@angular/core';
+import { FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { NbTabsetModule } from '@nebular/theme';
+import { QuillModule } from 'ngx-quill';
+import Quill from 'quill';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@nebular/theme";
+import * as i3 from "ngx-quill";
+import * as i4 from "@angular/forms";
+const Parchment = Quill.import('parchment');
+const AlignStyle = new Parchment.Attributor.Style('align', 'text-align', {
+    scope: Parchment.Scope.BLOCK,
+    whitelist: ['left', 'center', 'right', 'justify'],
+});
+const DirectionStyle = new Parchment.Attributor.Style('direction', 'direction', {
+    scope: Parchment.Scope.BLOCK,
+    whitelist: ['ltr', 'rtl'],
+});
+const IndentStyle = new Parchment.Attributor.Style('indent', 'padding-left', {
+    scope: Parchment.Scope.BLOCK,
+    whitelist: ['0px', '30px', '60px', '90px', '120px', '150px', '180px', '210px', '240px', '270px'],
+});
+Quill.register(AlignStyle, true);
+Quill.register(DirectionStyle, true);
+Quill.register(IndentStyle, true);
+let id = 1;
+class SclTextEditor {
+    set hasImageUpload(value) {
+        this.showImgConfig = coerceBooleanProperty(value);
+    }
+    get hasImageUpload() {
+        return this.showImgConfig;
+    }
+    set toolbarOptions(options) {
+        this._toolbarOptions = options;
+    }
+    get toolbarOptions() {
+        return this._toolbarOptions;
+    }
+    get quillConfig() {
+        return {
+            toolbar: {
+                container: this.hasImageUpload ? this.toolbarOptions : this.toolbarOptions.filter(group => group.length > 1 || group[0] !== 'image'),
+                handlers: {
+                    indent: (value) => {
+                        this.handleIndent(value);
+                    },
+                },
+            },
+            clipboard: {
+                matchVisual: false, // Prevents visual alignment of pasted content
+            },
+        };
+    }
+    constructor() {
+        this.showImgConfig = false;
+        this.isTabChanged = false;
+        this.imagePath = '';
+        this.content = '';
+        this.htmlContent = '';
+        this.id = 'editor-' + id++;
+        this.create = true;
+        this.saveAndPublishLoader = false;
+        this.saveLoader = false;
+        this.saveMode = '';
+        this.isVisualMode = true;
+        this.textEditorDisabled = false;
+        this._toolbarOptions = [
+            // Headings and structure
+            [{ header: [1, 2, 3, 4, 5, 6, false] }],
+            // Text formatting (basic)
+            ['bold', 'italic', 'underline', 'strike'],
+            // Text appearance
+            [{ color: [] }, { background: [] }],
+            // Lists and indentation (organization)
+            [{ list: 'ordered' }, { list: 'bullet' }],
+            [{ indent: '-1' }, { indent: '+1' }],
+            // Text alignment and direction
+            [{ align: [] }, { direction: 'rtl' }],
+            // Special text elements
+            [{ script: 'sub' }, { script: 'super' }],
+            ['blockquote', 'code-block'],
+            // Media and links
+            //add 'image' and 'video' if needed
+            ['link'],
+            // Cleaning
+            ['clean'],
+        ];
+        this.onChange = () => { };
+        this.htmlText = '';
+        this.hasFocus = false;
+        this.format = 'html';
+        this.onTouched = () => { };
+    }
+    onEditorCreated(editorInstance) {
+        this.quill = editorInstance;
+        this.addToolbarTooltips(editorInstance);
+    }
+    addToolbarTooltips(editorInstance) {
+        const toolbarModule = editorInstance.getModule('toolbar');
+        if (!toolbarModule || !toolbarModule.container)
+            return;
+        const toolbarContainer = toolbarModule.container;
+        const tooltipMap = {
+            bold: 'Bold',
+            italic: 'Italic',
+            underline: 'Underline',
+            strike: 'Strikethrough',
+            header: 'Header',
+            font: 'Font',
+            color: 'Text color',
+            background: 'Background color',
+            align: 'Align',
+            direction: 'Text direction',
+            blockquote: 'Blockquote',
+            'code-block': 'Code Block',
+            link: 'Link',
+            image: 'Image',
+            video: 'Video',
+            clean: 'Clear formatting',
+        };
+        const buttons = toolbarContainer.querySelectorAll('button');
+        buttons.forEach((btn) => {
+            const qlCommand = Array.from(btn.classList).find(cls => cls.startsWith('ql-'));
+            if (!qlCommand)
+                return;
+            const command = qlCommand.replace('ql-', '');
+            const tooltip = this.getTooltipForButton(command, btn, tooltipMap);
+            if (tooltip && !btn.hasAttribute('title')) {
+                btn.setAttribute('title', tooltip);
+            }
+        });
+        const pickerLabels = toolbarContainer.querySelectorAll('.ql-picker-label');
+        pickerLabels.forEach(label => {
+            if (label.hasAttribute('title'))
+                return;
+            const parentPicker = label.closest('.ql-picker');
+            if (!parentPicker)
+                return;
+            const commandClass = Array.from(parentPicker.classList).find(cls => cls.startsWith('ql-') && cls !== 'ql-picker');
+            if (!commandClass)
+                return;
+            const command = commandClass.replace('ql-', '');
+            const tooltip = tooltipMap[command] || '';
+            if (tooltip) {
+                label.setAttribute('title', tooltip);
+            }
+        });
+    }
+    getTooltipForButton(command, button, tooltipMap) {
+        const value = button.getAttribute('value') ?? '';
+        switch (command) {
+            case 'script':
+                if (value === 'sub')
+                    return 'Subscript';
+                if (value === 'super')
+                    return 'Superscript';
+                break;
+            case 'list':
+                if (value === 'ordered')
+                    return 'Ordered List';
+                if (value === 'bullet')
+                    return 'Bullet List';
+                break;
+            case 'indent':
+                if (value === '+1')
+                    return 'Increase Indent';
+                if (value === '-1')
+                    return 'Decrease Indent';
+                break;
+        }
+        return tooltipMap[command] || '';
+    }
+    handleIndent(value) {
+        const range = this.quill.getSelection();
+        if (!range)
+            return;
+        const format = this.quill.getFormat(range);
+        const currentIndent = format['indent'] || '0px';
+        const currentLevel = parseInt(currentIndent) / 30;
+        let newLevel;
+        if (value === '+1') {
+            newLevel = Math.min(currentLevel + 1, 9);
+        }
+        else {
+            newLevel = Math.max(currentLevel - 1, 0);
+        }
+        const newIndent = newLevel === 0 ? false : `${newLevel * 30}px`;
+        this.quill.format('indent', newIndent);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    writeValue(value) {
+        this.htmlText = value || '';
+    }
+    setDisabledState(isDisabled) {
+        this.textEditorDisabled = isDisabled;
+    }
+    tabChanged(event) {
+        switch (event.tabId) {
+            case 'VISUAL':
+                if (!this.isVisualMode) {
+                    this.isVisualMode = true;
+                    const htmlString = this.editor.quillEditor.getText().trim();
+                    this.editor.quillEditor.root.innerHTML = htmlString;
+                }
+                break;
+            case 'TEXT':
+                if (this.isVisualMode) {
+                    this.isVisualMode = false;
+                    const htmlContent = this.editor.quillEditor.root.innerHTML;
+                    this.editor.quillEditor.setText(htmlContent);
+                }
+                break;
+        }
+    }
+    onSelectionChanged(event) {
+        if (event.oldRange == null) {
+            this.onTouched();
+        }
+    }
+    onContentChanged(event) {
+        this.onChange(this.htmlText);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTextEditor, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: SclTextEditor, isStandalone: true, selector: "scl-text-editor", inputs: { tabLess: "tabLess", placeholder: "placeholder", hasImageUpload: "hasImageUpload", toolbarOptions: "toolbarOptions" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => SclTextEditor),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "editor", first: true, predicate: ["editor"], descendants: true }], ngImport: i0, template: "<div class=\"scl-text-editor\" [class.scl-text-editor--disabled]=\"textEditorDisabled\">\n    <quill-editor\n        [(ngModel)]=\"htmlText\"\n        [modules]=\"quillConfig\"\n        class=\"scl-text-editor__quill\"\n        (onSelectionChanged)=\"onSelectionChanged($event)\"\n        (onContentChanged)=\"onContentChanged($event)\"\n        [format]=\"format\"\n        #editor\n        (onEditorCreated)=\"onEditorCreated($event)\"\n        [placeholder]=\"placeholder\"></quill-editor>\n\n    <div class=\"scl-text-editor__tab\" *ngIf=\"!tabLess\">\n        <nb-tabset (changeTab)=\"tabChanged($event)\">\n            <nb-tab tabTitle=\"Visual\" tabId=\"VISUAL\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n            <nb-tab tabTitle=\"Text\" tabId=\"TEXT\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n        </nb-tabset>\n    </div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: NbTabsetModule }, { kind: "component", type: i2.NbTabsetComponent, selector: "nb-tabset", inputs: ["fullWidth", "routeParam"], outputs: ["changeTab"] }, { kind: "component", type: i2.NbTabComponent, selector: "nb-tab", inputs: ["tabTitle", "tabId", "badgeDot", "tabIcon", "disabled", "responsive", "route", "active", "lazyLoad", "badgeText", "badgeStatus", "badgePosition"] }, { kind: "ngmodule", type: QuillModule }, { kind: "component", type: i3.QuillEditorComponent, selector: "quill-editor" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] }); }
+}
+export { SclTextEditor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTextEditor, decorators: [{
+            type: Component,
+            args: [{ selector: 'scl-text-editor', standalone: true, imports: [CommonModule, NbTabsetModule, QuillModule, FormsModule], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SclTextEditor),
+                            multi: true,
+                        },
+                    ], template: "<div class=\"scl-text-editor\" [class.scl-text-editor--disabled]=\"textEditorDisabled\">\n    <quill-editor\n        [(ngModel)]=\"htmlText\"\n        [modules]=\"quillConfig\"\n        class=\"scl-text-editor__quill\"\n        (onSelectionChanged)=\"onSelectionChanged($event)\"\n        (onContentChanged)=\"onContentChanged($event)\"\n        [format]=\"format\"\n        #editor\n        (onEditorCreated)=\"onEditorCreated($event)\"\n        [placeholder]=\"placeholder\"></quill-editor>\n\n    <div class=\"scl-text-editor__tab\" *ngIf=\"!tabLess\">\n        <nb-tabset (changeTab)=\"tabChanged($event)\">\n            <nb-tab tabTitle=\"Visual\" tabId=\"VISUAL\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n            <nb-tab tabTitle=\"Text\" tabId=\"TEXT\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n        </nb-tabset>\n    </div>\n</div>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { tabLess: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], editor: [{
+                type: ViewChild,
+                args: ['editor']
+            }], hasImageUpload: [{
+                type: Input
+            }], toolbarOptions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-editor.js","sourceRoot":"","sources":["../../../../src/packages/text-editor/text-editor.ts","../../../../src/packages/text-editor/text-editor.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { CommonModule } from '@angular/common';\nimport { Component, Input, ViewChild, forwardRef } from '@angular/core';\nimport { FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { NbTabsetModule } from '@nebular/theme';\nimport { QuillEditorComponent, QuillModule } from 'ngx-quill';\nimport Quill from 'quill';\n\nconst Parchment = Quill.import('parchment');\nconst AlignStyle = new Parchment.Attributor.Style('align', 'text-align', {\n    scope: Parchment.Scope.BLOCK,\n    whitelist: ['left', 'center', 'right', 'justify'],\n});\n\nconst DirectionStyle = new Parchment.Attributor.Style('direction', 'direction', {\n    scope: Parchment.Scope.BLOCK,\n    whitelist: ['ltr', 'rtl'],\n});\n\nconst IndentStyle = new Parchment.Attributor.Style('indent', 'padding-left', {\n    scope: Parchment.Scope.BLOCK,\n    whitelist: ['0px', '30px', '60px', '90px', '120px', '150px', '180px', '210px', '240px', '270px'],\n});\n\nQuill.register(AlignStyle, true);\nQuill.register(DirectionStyle, true);\nQuill.register(IndentStyle, true);\n\nlet id = 1;\n\n@Component({\n    selector: 'scl-text-editor',\n    standalone: true,\n    imports: [CommonModule, NbTabsetModule, QuillModule, FormsModule],\n    templateUrl: './text-editor.html',\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => SclTextEditor),\n            multi: true,\n        },\n    ],\n})\nexport class SclTextEditor {\n    @Input() tabLess?: boolean;\n    @Input() placeholder?: string;\n    @ViewChild('editor') editor!: QuillEditorComponent;\n\n    showImgConfig = false;\n\n    @Input()\n    set hasImageUpload(value: any) {\n        this.showImgConfig = coerceBooleanProperty(value);\n    }\n    get hasImageUpload(): boolean {\n        return this.showImgConfig;\n    }\n\n    isTabChanged = false;\n    quill!: Quill;\n    imagePath = '';\n    content: string = '';\n    quillFile: any;\n    meQuillRef: any;\n    contentType!: string;\n    htmlContent: string = '';\n    id = 'editor-' + id++;\n    create = true;\n    saveAndPublishLoader = false;\n    saveLoader = false;\n    saveMode = '';\n    isVisualMode = true;\n    textEditorDisabled = false;\n\n    private _toolbarOptions: any[] = [\n        // Headings and structure\n        [{ header: [1, 2, 3, 4, 5, 6, false] }],\n\n        // Text formatting (basic)\n        ['bold', 'italic', 'underline', 'strike'],\n\n        // Text appearance\n        [{ color: [] }, { background: [] }],\n\n        // Lists and indentation (organization)\n        [{ list: 'ordered' }, { list: 'bullet' }],\n        [{ indent: '-1' }, { indent: '+1' }],\n\n        // Text alignment and direction\n        [{ align: [] }, { direction: 'rtl' }],\n\n        // Special text elements\n        [{ script: 'sub' }, { script: 'super' }],\n        ['blockquote', 'code-block'],\n\n        // Media and links\n        //add 'image' and 'video' if needed\n        ['link'],\n\n        // Cleaning\n        ['clean'],\n    ];\n\n    @Input()\n    set toolbarOptions(options: any[]) {\n        this._toolbarOptions = options;\n    }\n    get toolbarOptions(): any[] {\n        return this._toolbarOptions;\n    }\n\n    private onChange: (value: any) => void = () => {};\n    htmlText = '';\n    hasFocus = false;\n    format: any = 'html';\n    private onTouched: () => void = () => {};\n\n    get quillConfig() {\n        return {\n            toolbar: {\n                container: this.hasImageUpload ? this.toolbarOptions : this.toolbarOptions.filter(group => group.length > 1 || group[0] !== 'image'),\n                handlers: {\n                    indent: (value: string) => {\n                        this.handleIndent(value);\n                    },\n                },\n            },\n            clipboard: {\n                matchVisual: false, // Prevents visual alignment of pasted content\n            },\n        };\n    }\n\n    constructor() {}\n\n    onEditorCreated(editorInstance: Quill): void {\n        this.quill = editorInstance;\n        this.addToolbarTooltips(editorInstance);\n    }\n\n    private addToolbarTooltips(editorInstance: Quill): void {\n        const toolbarModule = editorInstance.getModule('toolbar');\n        if (!toolbarModule || !toolbarModule.container) return;\n\n        const toolbarContainer = toolbarModule.container as HTMLElement;\n        const tooltipMap: Record<string, string> = {\n            bold: 'Bold',\n            italic: 'Italic',\n            underline: 'Underline',\n            strike: 'Strikethrough',\n            header: 'Header',\n            font: 'Font',\n            color: 'Text color',\n            background: 'Background color',\n            align: 'Align',\n            direction: 'Text direction',\n            blockquote: 'Blockquote',\n            'code-block': 'Code Block',\n            link: 'Link',\n            image: 'Image',\n            video: 'Video',\n            clean: 'Clear formatting',\n        };\n\n        const buttons = toolbarContainer.querySelectorAll('button');\n        buttons.forEach((btn: HTMLElement) => {\n            const qlCommand = Array.from(btn.classList).find(cls => cls.startsWith('ql-'));\n            if (!qlCommand) return;\n\n            const command = qlCommand.replace('ql-', '');\n            const tooltip = this.getTooltipForButton(command, btn, tooltipMap);\n            if (tooltip && !btn.hasAttribute('title')) {\n                btn.setAttribute('title', tooltip);\n            }\n        });\n\n        const pickerLabels = toolbarContainer.querySelectorAll('.ql-picker-label');\n        pickerLabels.forEach(label => {\n            if (label.hasAttribute('title')) return;\n            const parentPicker = label.closest('.ql-picker');\n            if (!parentPicker) return;\n\n            const commandClass = Array.from(parentPicker.classList).find(cls => cls.startsWith('ql-') && cls !== 'ql-picker');\n            if (!commandClass) return;\n\n            const command = commandClass.replace('ql-', '');\n            const tooltip = tooltipMap[command] || '';\n            if (tooltip) {\n                label.setAttribute('title', tooltip);\n            }\n        });\n    }\n\n    private getTooltipForButton(command: string, button: HTMLElement, tooltipMap: Record<string, string>): string {\n        const value = button.getAttribute('value') ?? '';\n        switch (command) {\n            case 'script':\n                if (value === 'sub') return 'Subscript';\n                if (value === 'super') return 'Superscript';\n                break;\n            case 'list':\n                if (value === 'ordered') return 'Ordered List';\n                if (value === 'bullet') return 'Bullet List';\n                break;\n            case 'indent':\n                if (value === '+1') return 'Increase Indent';\n                if (value === '-1') return 'Decrease Indent';\n                break;\n        }\n        return tooltipMap[command] || '';\n    }\n\n    private handleIndent(value: string): void {\n        const range = this.quill.getSelection();\n        if (!range) return;\n\n        const format = this.quill.getFormat(range);\n        const currentIndent = format['indent'] || '0px';\n        const currentLevel = parseInt(currentIndent) / 30;\n\n        let newLevel: number;\n        if (value === '+1') {\n            newLevel = Math.min(currentLevel + 1, 9);\n        } else {\n            newLevel = Math.max(currentLevel - 1, 0);\n        }\n\n        const newIndent = newLevel === 0 ? false : `${newLevel * 30}px`;\n        this.quill.format('indent', newIndent);\n    }\n\n    registerOnChange(fn: any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouched = fn;\n    }\n\n    writeValue(value: any): void {\n        this.htmlText = value || '';\n    }\n\n    setDisabledState(isDisabled: boolean): void {\n        this.textEditorDisabled = isDisabled;\n    }\n\n    tabChanged(event: any) {\n        switch (event.tabId) {\n            case 'VISUAL':\n                if (!this.isVisualMode) {\n                    this.isVisualMode = true;\n                    const htmlString = this.editor.quillEditor.getText().trim();\n                    this.editor.quillEditor.root.innerHTML = htmlString;\n                }\n                break;\n            case 'TEXT':\n                if (this.isVisualMode) {\n                    this.isVisualMode = false;\n                    const htmlContent = this.editor.quillEditor.root.innerHTML;\n                    this.editor.quillEditor.setText(htmlContent);\n                }\n                break;\n        }\n    }\n\n    onSelectionChanged(event: any): void {\n        if (event.oldRange == null) {\n            this.onTouched();\n        }\n    }\n\n    onContentChanged(event: any): void {\n        this.onChange(this.htmlText);\n    }\n}\n","<div class=\"scl-text-editor\" [class.scl-text-editor--disabled]=\"textEditorDisabled\">\n    <quill-editor\n        [(ngModel)]=\"htmlText\"\n        [modules]=\"quillConfig\"\n        class=\"scl-text-editor__quill\"\n        (onSelectionChanged)=\"onSelectionChanged($event)\"\n        (onContentChanged)=\"onContentChanged($event)\"\n        [format]=\"format\"\n        #editor\n        (onEditorCreated)=\"onEditorCreated($event)\"\n        [placeholder]=\"placeholder\"></quill-editor>\n\n    <div class=\"scl-text-editor__tab\" *ngIf=\"!tabLess\">\n        <nb-tabset (changeTab)=\"tabChanged($event)\">\n            <nb-tab tabTitle=\"Visual\" tabId=\"VISUAL\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n            <nb-tab tabTitle=\"Text\" tabId=\"TEXT\" [disabled]=\"textEditorDisabled\"> </nb-tab>\n        </nb-tabset>\n    </div>\n</div>\n"]}

package/esm2022/theme.provider.mjs

@@ -0,0 +1,9 @@
+import { NbThemeModule } from '@nebular/theme';
+export function themeProvider(themeName = 'default') {
+    return [
+        NbThemeModule.forRoot({
+            name: themeName,
+        }).providers,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcGFja2FnZXMvdGhlbWUucHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRS9DLE1BQU0sVUFBVSxhQUFhLENBQUMsWUFBb0IsU0FBUztJQUN2RCxPQUFPO1FBQ0gsYUFBYSxDQUFDLE9BQU8sQ0FBQztZQUNsQixJQUFJLEVBQUUsU0FBUztTQUNsQixDQUFDLENBQUMsU0FBUztLQUNmLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmJUaGVtZU1vZHVsZSB9IGZyb20gJ0BuZWJ1bGFyL3RoZW1lJztcblxuZXhwb3J0IGZ1bmN0aW9uIHRoZW1lUHJvdmlkZXIodGhlbWVOYW1lOiBzdHJpbmcgPSAnZGVmYXVsdCcpIHtcbiAgICByZXR1cm4gW1xuICAgICAgICBOYlRoZW1lTW9kdWxlLmZvclJvb3Qoe1xuICAgICAgICAgICAgbmFtZTogdGhlbWVOYW1lLFxuICAgICAgICB9KS5wcm92aWRlcnMsXG4gICAgXTtcbn1cbiJdfQ==

package/esm2022/timeline/timeline.component.mjs

@@ -0,0 +1,66 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { NbCardModule } from '@nebular/theme';
+import * as moment from 'moment';
+import { SclBadge } from '../badge/badge';
+import { SclTruncate } from '../truncate/truncate.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@nebular/theme";
+class SclTimelineComponent {
+    get data() {
+        return this._data;
+    }
+    set data(value) {
+        this._data = value;
+        this.groupedData = this.groupByMonth(this._data);
+    }
+    constructor() {
+        this.onClick = new EventEmitter();
+        this._data = [];
+        this.groupedData = [];
+    }
+    onSelect(value) {
+        if (value.active) {
+            return;
+        }
+        this.data.forEach(item => {
+            item.active = item === value;
+        });
+        this.onClick.emit(value);
+    }
+    groupByMonth(items) {
+        const groupedData = {};
+        items?.forEach(item => {
+            const formattedDate = moment(item.description).format('YYYY-MM');
+            if (!groupedData[formattedDate]) {
+                groupedData[formattedDate] = [];
+            }
+            groupedData[formattedDate].push(item);
+        });
+        return Object.keys(groupedData).map(date => ({
+            date,
+            remainingData: groupedData[date],
+        }));
+    }
+    getMetadata(item) {
+        const ignore = ['label', 'description', 'active', 'id'];
+        return Object.keys(item)
+            .filter(key => !ignore.includes(key))
+            .map(key => item[key]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTimelineComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: SclTimelineComponent, isStandalone: true, selector: "scl-timeline", inputs: { data: "data" }, outputs: { onClick: "onClick" }, host: { classAttribute: "scl-timeline" }, ngImport: i0, template: "<div class=\"scl-timeline__aside\">\n    <nb-card class=\"scl-timeline__card\">\n        <nb-card-body class=\"scl-timeline__card-body\">\n            <section class=\"scl-timeline__wrapper\" *ngFor=\"let group of groupedData\">\n                <h3 class=\"scl-timeline__title\">{{ group.date | date: 'MMM, y' }}</h3>\n\n                <div class=\"scl-timeline-item\" *ngFor=\"let item of group.remainingData; let i = index\">\n                    <div class=\"scl-timeline-item__bullet-wrapper\">\n                        <span class=\"scl-timeline-item__bullet\" [class.active]=\"item?.active\"></span>\n                        <div class=\"scl-timeline-item__line\" *ngIf=\"i < group.remainingData.length - 1\"></div>\n                    </div>\n                    <button class=\"scl-timeline-item__card\" (click)=\"onSelect(item)\" [class.active]=\"item?.active\">\n                        <div class=\"scl-timeline-item__content\">\n                            <span class=\"scl-timeline-item__label\" sclTruncate=\"1\">{{ item?.label }}</span>\n                            <scl-badge *ngIf=\"item === data[0]\" status=\"success\"> CURRENT </scl-badge>\n                        </div>\n                        <span class=\"scl-timeline-item__info\">{{ item?.description | date: \"MMM d 'at' hh:mm a\" }}</span>\n                        <ng-container *ngFor=\"let value of getMetadata(item)\">\n                            <span class=\"scl-timeline-item__info\">{{ value }}</span>\n                        </ng-container>\n                    </button>\n                </div>\n            </section>\n        </nb-card-body>\n    </nb-card>\n</div>\n\n<div class=\"scl-timeline__content\">\n    <ng-content></ng-content>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.DatePipe, name: "date" }, { kind: "directive", type: SclBadge, selector: "scl-badge", inputs: ["status"] }, { kind: "directive", type: SclTruncate, selector: "[sclTruncate]", inputs: ["sclTruncate"] }, { kind: "ngmodule", type: NbCardModule }, { kind: "component", type: i2.NbCardComponent, selector: "nb-card", inputs: ["size", "status", "accent"] }, { kind: "component", type: i2.NbCardBodyComponent, selector: "nb-card-body" }] }); }
+}
+export { SclTimelineComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SclTimelineComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'scl-timeline', standalone: true, imports: [CommonModule, SclBadge, SclTruncate, NbCardModule], host: {
+                        class: 'scl-timeline',
+                    }, template: "<div class=\"scl-timeline__aside\">\n    <nb-card class=\"scl-timeline__card\">\n        <nb-card-body class=\"scl-timeline__card-body\">\n            <section class=\"scl-timeline__wrapper\" *ngFor=\"let group of groupedData\">\n                <h3 class=\"scl-timeline__title\">{{ group.date | date: 'MMM, y' }}</h3>\n\n                <div class=\"scl-timeline-item\" *ngFor=\"let item of group.remainingData; let i = index\">\n                    <div class=\"scl-timeline-item__bullet-wrapper\">\n                        <span class=\"scl-timeline-item__bullet\" [class.active]=\"item?.active\"></span>\n                        <div class=\"scl-timeline-item__line\" *ngIf=\"i < group.remainingData.length - 1\"></div>\n                    </div>\n                    <button class=\"scl-timeline-item__card\" (click)=\"onSelect(item)\" [class.active]=\"item?.active\">\n                        <div class=\"scl-timeline-item__content\">\n                            <span class=\"scl-timeline-item__label\" sclTruncate=\"1\">{{ item?.label }}</span>\n                            <scl-badge *ngIf=\"item === data[0]\" status=\"success\"> CURRENT </scl-badge>\n                        </div>\n                        <span class=\"scl-timeline-item__info\">{{ item?.description | date: \"MMM d 'at' hh:mm a\" }}</span>\n                        <ng-container *ngFor=\"let value of getMetadata(item)\">\n                            <span class=\"scl-timeline-item__info\">{{ value }}</span>\n                        </ng-container>\n                    </button>\n                </div>\n            </section>\n        </nb-card-body>\n    </nb-card>\n</div>\n\n<div class=\"scl-timeline__content\">\n    <ng-content></ng-content>\n</div>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { onClick: [{
+                type: Output
+            }], data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timeline.component.js","sourceRoot":"","sources":["../../../../src/packages/timeline/timeline.component.ts","../../../../src/packages/timeline/timeline.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;;;;AAU7D,MASa,oBAAoB;IAK7B,IAAa,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAI,IAAI,CAAC,KAAwB;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAID;QAfU,YAAO,GAAkC,IAAI,YAAY,EAAE,CAAC;QAE9D,UAAK,GAAsB,EAAE,CAAC;QAWtC,gBAAW,GAAU,EAAE,CAAC;IAET,CAAC;IAEhB,QAAQ,CAAC,KAAsB;QAC3B,IAAI,KAAK,CAAC,MAAM,EAAE;YACd,OAAO;SACV;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACrB,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,KAAK,CAAC;QACjC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,YAAY,CAAC,KAAY;QACrB,MAAM,WAAW,GAA8B,EAAE,CAAC;QAClD,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE;YAClB,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACjE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE;gBAC7B,WAAW,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;aACnC;YACD,WAAW,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACzC,IAAI;YACJ,aAAa,EAAE,WAAW,CAAC,IAAI,CAAC;SACnC,CAAC,CAAC,CAAC;IACR,CAAC;IAED,WAAW,CAAC,IAAqB;QAC7B,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;aACnB,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;aACpC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,CAAC;8GAjDQ,oBAAoB;kGAApB,oBAAoB,6KCxBjC,itDA8BA,2CDXc,YAAY,mTAAE,QAAQ,0EAAE,WAAW,kFAAE,YAAY;;SAKlD,oBAAoB;2FAApB,oBAAoB;kBAThC,SAAS;+BACI,cAAc,cAEZ,IAAI,WACP,CAAC,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,CAAC,QACtD;wBACF,KAAK,EAAE,cAAc;qBACxB;0EAGS,OAAO;sBAAhB,MAAM;gBAIM,IAAI;sBAAhB,KAAK","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { NbCardModule } from '@nebular/theme';\nimport * as moment from 'moment';\nimport { SclBadge } from '../badge/badge';\nimport { SclTruncate } from '../truncate/truncate.component';\n\nexport interface SclTimelineItem {\n    label: string;\n    description: string;\n    active: boolean;\n    id: string;\n    [key: string]: any;\n}\n\n@Component({\n    selector: 'scl-timeline',\n    templateUrl: './timeline.component.html',\n    standalone: true,\n    imports: [CommonModule, SclBadge, SclTruncate, NbCardModule],\n    host: {\n        class: 'scl-timeline',\n    },\n})\nexport class SclTimelineComponent {\n    @Output() onClick: EventEmitter<SclTimelineItem> = new EventEmitter();\n\n    private _data: SclTimelineItem[] = [];\n\n    @Input() get data(): SclTimelineItem[] {\n        return this._data;\n    }\n\n    set data(value: SclTimelineItem[]) {\n        this._data = value;\n        this.groupedData = this.groupByMonth(this._data);\n    }\n\n    groupedData: any[] = [];\n\n    constructor() {}\n\n    onSelect(value: SclTimelineItem) {\n        if (value.active) {\n            return;\n        }\n        this.data.forEach(item => {\n            item.active = item === value;\n        });\n        this.onClick.emit(value);\n    }\n\n    groupByMonth(items: any[]) {\n        const groupedData: { [date: string]: any[] } = {};\n        items?.forEach(item => {\n            const formattedDate = moment(item.description).format('YYYY-MM');\n            if (!groupedData[formattedDate]) {\n                groupedData[formattedDate] = [];\n            }\n            groupedData[formattedDate].push(item);\n        });\n\n        return Object.keys(groupedData).map(date => ({\n            date,\n            remainingData: groupedData[date],\n        }));\n    }\n\n    getMetadata(item: SclTimelineItem): any[] {\n        const ignore = ['label', 'description', 'active', 'id'];\n        return Object.keys(item)\n            .filter(key => !ignore.includes(key))\n            .map(key => item[key]);\n    }\n}\n","<div class=\"scl-timeline__aside\">\n    <nb-card class=\"scl-timeline__card\">\n        <nb-card-body class=\"scl-timeline__card-body\">\n            <section class=\"scl-timeline__wrapper\" *ngFor=\"let group of groupedData\">\n                <h3 class=\"scl-timeline__title\">{{ group.date | date: 'MMM, y' }}</h3>\n\n                <div class=\"scl-timeline-item\" *ngFor=\"let item of group.remainingData; let i = index\">\n                    <div class=\"scl-timeline-item__bullet-wrapper\">\n                        <span class=\"scl-timeline-item__bullet\" [class.active]=\"item?.active\"></span>\n                        <div class=\"scl-timeline-item__line\" *ngIf=\"i < group.remainingData.length - 1\"></div>\n                    </div>\n                    <button class=\"scl-timeline-item__card\" (click)=\"onSelect(item)\" [class.active]=\"item?.active\">\n                        <div class=\"scl-timeline-item__content\">\n                            <span class=\"scl-timeline-item__label\" sclTruncate=\"1\">{{ item?.label }}</span>\n                            <scl-badge *ngIf=\"item === data[0]\" status=\"success\"> CURRENT </scl-badge>\n                        </div>\n                        <span class=\"scl-timeline-item__info\">{{ item?.description | date: \"MMM d 'at' hh:mm a\" }}</span>\n                        <ng-container *ngFor=\"let value of getMetadata(item)\">\n                            <span class=\"scl-timeline-item__info\">{{ value }}</span>\n                        </ng-container>\n                    </button>\n                </div>\n            </section>\n        </nb-card-body>\n    </nb-card>\n</div>\n\n<div class=\"scl-timeline__content\">\n    <ng-content></ng-content>\n</div>\n"]}