@koobiq/components 18.33.0 → 18.35.0

package/esm2022/clamped-text/clamped-text.mjs

@@ -0,0 +1,202 @@
+import { SharedResizeObserver } from '@angular/cdk/observers/private';
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, input, numberAttribute, output, signal, viewChild, ViewEncapsulation } from '@angular/core';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { KbqButtonModule } from '@koobiq/components/button';
+import { KBQ_LOCALE_SERVICE } from '@koobiq/components/core';
+import { KbqIcon } from '@koobiq/components/icon';
+import { KbqLinkModule } from '@koobiq/components/link';
+import { debounceTime, map, of, pairwise, skip } from 'rxjs';
+import { KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION, kbqClampedTextDefaultMaxRows } from './constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@koobiq/components/link";
+export class KbqClampedText {
+    constructor() {
+        /**
+         * Max rows before text is clamped.
+         * @default kbqClampedTextDefaultMaxRows
+         */
+        this.rows = input(kbqClampedTextDefaultMaxRows);
+        /** Collapsed state: `true` = collapsed, `false` = expanded, `undefined` = auto. */
+        this.isCollapsed = input();
+        /**
+         * Debounce time on resize observer when recalculating toggle and text visibility.
+         * @default 0
+         */
+        this.debounceTime = input(0, { transform: numberAttribute });
+        /** Emits when collapsed state changes. Used for two-way binding with `isCollapsed`. */
+        this.isCollapsedChange = output();
+        /** @docs-private */
+        this.text = viewChild.required('text');
+        /** @docs-private */
+        this.textContainer = viewChild.required('textContainer');
+        /**
+         * This flag controls event emission, aria/css-class calculation
+         * @docs-private
+         */
+        this.collapsedState = signal(undefined);
+        /** @docs-private */
+        this.isToggleCollapsed = signal(undefined);
+        /** @docs-private */
+        this.hasToggle = signal(true);
+        /** @docs-private */
+        this.lineClamp = signal(null);
+        this.destroyRef = inject(DestroyRef);
+        this.elementRef = inject(ElementRef);
+        this.resizeObserver = inject(SharedResizeObserver);
+        this.localeService = inject(KBQ_LOCALE_SERVICE, { optional: true });
+        /**
+         * Clamped text locale configuration.
+         * @docs-private
+         */
+        this.localeConfiguration = toSignal(this.localeService
+            ? this.localeService.changes.pipe(map(() => this.localeService.getParams('clampedText')))
+            : of(inject(KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION)));
+        /**
+         * This flag is used to prevent trigger resize observer on toggle click.
+         */
+        this.isEventFromToggle = false;
+        /**
+         * Calculates next collapsed state according to previous one.
+         * `undefined` is treated as collapsed and not touched stated.
+         */
+        this.toggleCollapseState = (state) => {
+            const isCollapsed = state ?? true;
+            return !isCollapsed;
+        };
+        toObservable(this.isCollapsed)
+            .pipe(pairwise(), takeUntilDestroyed())
+            .subscribe(([previous, current]) => {
+            this.collapsedState.set(current);
+            // store previous collapsed value to reduce unnecessary changes
+            this.isToggleCollapsed.set(!this.hasToggle() ? previous : current);
+        });
+        toObservable(this.collapsedState)
+            .pipe(skip(1), takeUntilDestroyed())
+            .subscribe((collapsed) => {
+            if (collapsed === undefined)
+                return;
+            this.isCollapsedChange.emit(collapsed);
+        });
+        toObservable(this.rows)
+            .pipe(takeUntilDestroyed())
+            .subscribe((rows) => this.lineClamp.set(rows));
+    }
+    ngAfterViewInit() {
+        const textContainer = this.textContainer().nativeElement;
+        this.resizeObserver
+            .observe(textContainer)
+            .pipe(debounceTime(this.debounceTime()), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.updateToggleVisibilityState();
+            this.updateCollapsedState();
+        });
+    }
+    /** @docs-private */
+    toggleIsCollapsed(event) {
+        event.stopPropagation();
+        this.collapsedState.update((state) => this.toggleCollapseState(this.isToggleCollapsed() ?? state));
+        this.isToggleCollapsed.update(this.toggleCollapseState);
+        this.isEventFromToggle = true;
+        if (this.collapsedState()) {
+            setTimeout(() => this.elementRef.nativeElement.scrollIntoView({ block: 'center', inline: 'center' }));
+        }
+    }
+    updateToggleVisibilityState() {
+        this.hasToggle.set(this.getRowsCount() > this.rows() + 1);
+    }
+    updateCollapsedState() {
+        if (this.isEventFromToggle) {
+            this.isEventFromToggle = false;
+            return;
+        }
+        this.collapsedState.set(this.hasToggle() && (this.isToggleCollapsed() ?? true));
+    }
+    getRowsCount() {
+        const rects = Array.from(this.text().nativeElement.getClientRects());
+        return [...new Set(rects.map(({ top }) => top))].length;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedText, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: KbqClampedText, isStandalone: true, selector: "kbq-clamped-text", inputs: { rows: { classPropertyName: "rows", publicName: "rows", isSignal: true, isRequired: false, transformFunction: null }, isCollapsed: { classPropertyName: "isCollapsed", publicName: "isCollapsed", isSignal: true, isRequired: false, transformFunction: null }, debounceTime: { classPropertyName: "debounceTime", publicName: "debounceTime", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { isCollapsedChange: "isCollapsedChange" }, host: { properties: { "attr.aria-expanded": "collapsedState() ? \"false\" : \"true\"" }, classAttribute: "kbq-clamped-text" }, viewQueries: [{ propertyName: "text", first: true, predicate: ["text"], descendants: true, isSignal: true }, { propertyName: "textContainer", first: true, predicate: ["textContainer"], descendants: true, isSignal: true }], exportAs: ["kbqClampedText"], ngImport: i0, template: `
+        <div
+            #textContainer
+            class="kbq-clamped-text__content"
+            [style.-webkit-line-clamp]="lineClamp()"
+            [style.line-clamp]="lineClamp()"
+            [class.kbq-clamped-text__content_collapsed]="collapsedState()"
+        >
+            <span #text>
+                <ng-content />
+            </span>
+        </div>
+
+        @if (hasToggle()) {
+            <span
+                class="kbq-clamped-text__toggle"
+                kbq-link
+                noUnderline
+                pseudo
+                role="button"
+                (click)="toggleIsCollapsed($event)"
+                (keydown.enter)="toggleIsCollapsed($event)"
+                (keydown.space)="toggleIsCollapsed($event)"
+            >
+                @let config = localeConfiguration();
+
+                @if (collapsedState()) {
+                    <i kbq-icon="kbq-chevron-down_16"></i>
+                    <span class="kbq-link__text">{{ config!.openText }}</span>
+                } @else {
+                    <i kbq-icon="kbq-chevron-up_16"></i>
+                    <span class="kbq-link__text">{{ config!.closeText }}</span>
+                }
+            </span>
+        }
+    `, isInline: true, styles: [".kbq-clamped-text{display:inline-flex;flex-direction:column}.kbq-clamped-text__content.kbq-clamped-text__content_collapsed{display:-webkit-box;overflow-y:hidden;-webkit-box-orient:vertical}.kbq-clamped-text__toggle{margin-top:var(--kbq-size-xxs);align-self:flex-start}\n"], dependencies: [{ kind: "component", type: KbqIcon, selector: "[kbq-icon]", inputs: ["small", "autoColor", "kbq-icon"] }, { kind: "ngmodule", type: KbqButtonModule }, { kind: "ngmodule", type: KbqLinkModule }, { kind: "directive", type: i1.KbqLink, selector: "[kbq-link]", inputs: ["disabled", "tabIndex", "pseudo", "noUnderline", "big", "compact", "useVisited", "print"], exportAs: ["kbqLink"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedText, decorators: [{
+            type: Component,
+            args: [{ selector: 'kbq-clamped-text', standalone: true, exportAs: 'kbqClampedText', imports: [
+                        KbqIcon,
+                        KbqButtonModule,
+                        KbqLinkModule
+                    ], template: `
+        <div
+            #textContainer
+            class="kbq-clamped-text__content"
+            [style.-webkit-line-clamp]="lineClamp()"
+            [style.line-clamp]="lineClamp()"
+            [class.kbq-clamped-text__content_collapsed]="collapsedState()"
+        >
+            <span #text>
+                <ng-content />
+            </span>
+        </div>
+
+        @if (hasToggle()) {
+            <span
+                class="kbq-clamped-text__toggle"
+                kbq-link
+                noUnderline
+                pseudo
+                role="button"
+                (click)="toggleIsCollapsed($event)"
+                (keydown.enter)="toggleIsCollapsed($event)"
+                (keydown.space)="toggleIsCollapsed($event)"
+            >
+                @let config = localeConfiguration();
+
+                @if (collapsedState()) {
+                    <i kbq-icon="kbq-chevron-down_16"></i>
+                    <span class="kbq-link__text">{{ config!.openText }}</span>
+                } @else {
+                    <i kbq-icon="kbq-chevron-up_16"></i>
+                    <span class="kbq-link__text">{{ config!.closeText }}</span>
+                }
+            </span>
+        }
+    `, host: {
+                        class: 'kbq-clamped-text',
+                        '[attr.aria-expanded]': 'collapsedState() ? "false" : "true"'
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".kbq-clamped-text{display:inline-flex;flex-direction:column}.kbq-clamped-text__content.kbq-clamped-text__content_collapsed{display:-webkit-box;overflow-y:hidden;-webkit-box-orient:vertical}.kbq-clamped-text__toggle{margin-top:var(--kbq-size-xxs);align-self:flex-start}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clamped-text.js","sourceRoot":"","sources":["../../../../packages/components/clamped-text/clamped-text.ts"],"names":[],"mappings":"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","sourcesContent":["import { SharedResizeObserver } from '@angular/cdk/observers/private';\nimport {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Component,\n    DestroyRef,\n    ElementRef,\n    inject,\n    input,\n    numberAttribute,\n    output,\n    signal,\n    viewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { KbqButtonModule } from '@koobiq/components/button';\nimport { KBQ_LOCALE_SERVICE, KbqClampedTextLocaleConfig } from '@koobiq/components/core';\nimport { KbqIcon } from '@koobiq/components/icon';\nimport { KbqLinkModule } from '@koobiq/components/link';\nimport { debounceTime, map, of, pairwise, skip } from 'rxjs';\nimport { KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION, kbqClampedTextDefaultMaxRows } from './constants';\n\n@Component({\n    selector: 'kbq-clamped-text',\n    standalone: true,\n    exportAs: 'kbqClampedText',\n    imports: [\n        KbqIcon,\n        KbqButtonModule,\n        KbqLinkModule\n    ],\n    template: `\n        <div\n            #textContainer\n            class=\"kbq-clamped-text__content\"\n            [style.-webkit-line-clamp]=\"lineClamp()\"\n            [style.line-clamp]=\"lineClamp()\"\n            [class.kbq-clamped-text__content_collapsed]=\"collapsedState()\"\n        >\n            <span #text>\n                <ng-content />\n            </span>\n        </div>\n\n        @if (hasToggle()) {\n            <span\n                class=\"kbq-clamped-text__toggle\"\n                kbq-link\n                noUnderline\n                pseudo\n                role=\"button\"\n                (click)=\"toggleIsCollapsed($event)\"\n                (keydown.enter)=\"toggleIsCollapsed($event)\"\n                (keydown.space)=\"toggleIsCollapsed($event)\"\n            >\n                @let config = localeConfiguration();\n\n                @if (collapsedState()) {\n                    <i kbq-icon=\"kbq-chevron-down_16\"></i>\n                    <span class=\"kbq-link__text\">{{ config!.openText }}</span>\n                } @else {\n                    <i kbq-icon=\"kbq-chevron-up_16\"></i>\n                    <span class=\"kbq-link__text\">{{ config!.closeText }}</span>\n                }\n            </span>\n        }\n    `,\n    styleUrls: ['./clamped-text.scss'],\n    host: {\n        class: 'kbq-clamped-text',\n        '[attr.aria-expanded]': 'collapsedState() ? \"false\" : \"true\"'\n    },\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class KbqClampedText implements AfterViewInit {\n    /**\n     * Max rows before text is clamped.\n     * @default kbqClampedTextDefaultMaxRows\n     */\n    readonly rows = input<number>(kbqClampedTextDefaultMaxRows);\n    /** Collapsed state: `true` = collapsed, `false` = expanded, `undefined` = auto. */\n    readonly isCollapsed = input<boolean>();\n    /**\n     * Debounce time on resize observer when recalculating toggle and text visibility.\n     * @default 0\n     */\n    readonly debounceTime = input(0, { transform: numberAttribute });\n    /** Emits when collapsed state changes. Used for two-way binding with `isCollapsed`. */\n    readonly isCollapsedChange = output<boolean>();\n\n    /** @docs-private */\n    readonly text = viewChild.required<ElementRef<HTMLSpanElement>>('text');\n    /** @docs-private */\n    readonly textContainer = viewChild.required<ElementRef<HTMLDivElement>>('textContainer');\n\n    /**\n     * This flag controls event emission, aria/css-class calculation\n     * @docs-private\n     */\n    protected readonly collapsedState = signal<boolean | undefined>(undefined);\n    /** @docs-private */\n    protected readonly isToggleCollapsed = signal<boolean | undefined>(undefined);\n    /** @docs-private */\n    protected readonly hasToggle = signal(true);\n    /** @docs-private */\n    protected readonly lineClamp = signal<number | null>(null);\n\n    private readonly destroyRef = inject(DestroyRef);\n    private readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n    private readonly resizeObserver = inject(SharedResizeObserver);\n    private readonly localeService = inject(KBQ_LOCALE_SERVICE, { optional: true });\n\n    /**\n     * Clamped text locale configuration.\n     * @docs-private\n     */\n    protected readonly localeConfiguration = toSignal<KbqClampedTextLocaleConfig>(\n        this.localeService\n            ? this.localeService.changes.pipe(\n                  map(() => this.localeService!.getParams('clampedText') satisfies KbqClampedTextLocaleConfig)\n              )\n            : of(inject(KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION))\n    );\n\n    /**\n     * This flag is used to prevent trigger resize observer on toggle click.\n     */\n    private isEventFromToggle = false;\n\n    constructor() {\n        toObservable(this.isCollapsed)\n            .pipe(pairwise(), takeUntilDestroyed())\n            .subscribe(([previous, current]) => {\n                this.collapsedState.set(current);\n                // store previous collapsed value to reduce unnecessary changes\n                this.isToggleCollapsed.set(!this.hasToggle() ? previous : current);\n            });\n\n        toObservable(this.collapsedState)\n            .pipe(skip(1), takeUntilDestroyed())\n            .subscribe((collapsed) => {\n                if (collapsed === undefined) return;\n                this.isCollapsedChange.emit(collapsed);\n            });\n\n        toObservable(this.rows)\n            .pipe(takeUntilDestroyed())\n            .subscribe((rows) => this.lineClamp.set(rows));\n    }\n\n    ngAfterViewInit(): void {\n        const textContainer = this.textContainer().nativeElement;\n\n        this.resizeObserver\n            .observe(textContainer)\n            .pipe(debounceTime(this.debounceTime()), takeUntilDestroyed(this.destroyRef))\n            .subscribe(() => {\n                this.updateToggleVisibilityState();\n                this.updateCollapsedState();\n            });\n    }\n\n    /** @docs-private */\n    toggleIsCollapsed(event: Event): void {\n        event.stopPropagation();\n\n        this.collapsedState.update((state) => this.toggleCollapseState(this.isToggleCollapsed() ?? state));\n        this.isToggleCollapsed.update(this.toggleCollapseState);\n\n        this.isEventFromToggle = true;\n\n        if (this.collapsedState()) {\n            setTimeout(() => this.elementRef.nativeElement.scrollIntoView({ block: 'center', inline: 'center' }));\n        }\n    }\n\n    private updateToggleVisibilityState(): void {\n        this.hasToggle.set(this.getRowsCount() > this.rows() + 1);\n    }\n\n    private updateCollapsedState(): void {\n        if (this.isEventFromToggle) {\n            this.isEventFromToggle = false;\n\n            return;\n        }\n\n        this.collapsedState.set(this.hasToggle() && (this.isToggleCollapsed() ?? true));\n    }\n\n    /**\n     * Calculates next collapsed state according to previous one.\n     * `undefined` is treated as collapsed and not touched stated.\n     */\n    private toggleCollapseState = (state: boolean | undefined): boolean => {\n        const isCollapsed = state ?? true;\n\n        return !isCollapsed;\n    };\n\n    private getRowsCount(): number {\n        const rects = Array.from(this.text().nativeElement.getClientRects());\n\n        return [...new Set(rects.map(({ top }) => top))].length;\n    }\n}\n"]}

package/esm2022/clamped-text/constants.mjs

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { ruRULocaleData } from '@koobiq/components/core';
+/**
+ * Default maximum number of visible rows for the clamped text component
+ * before truncation and the "collapse/expand" toggle is shown.
+ */
+export const kbqClampedTextDefaultMaxRows = 5;
+/** Localization configuration provider. */
+export const KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION = new InjectionToken('KbqClampedTextLocaleConfig', {
+    factory: () => ruRULocaleData.clampedText
+});
+/**
+ * Utility provider.
+ * @see KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION
+ */
+export const kbqClampedTextLocaleConfigurationProvider = (configuration) => ({
+    provide: KBQ_CLAMPED_TEXT_LOCALE_CONFIGURATION,
+    useValue: configuration
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcG9uZW50cy9jbGFtcGVkLXRleHQvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQVksTUFBTSxlQUFlLENBQUM7QUFDekQsT0FBTyxFQUE4QixjQUFjLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVyRjs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBRyxDQUFDLENBQUM7QUFFOUMsMkNBQTJDO0FBQzNDLE1BQU0sQ0FBQyxNQUFNLHFDQUFxQyxHQUFHLElBQUksY0FBYyxDQUNuRSw0QkFBNEIsRUFDNUI7SUFDSSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDLFdBQVc7Q0FDNUMsQ0FDSixDQUFDO0FBRUY7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0seUNBQXlDLEdBQUcsQ0FBQyxhQUF5QyxFQUFZLEVBQUUsQ0FBQyxDQUFDO0lBQy9HLE9BQU8sRUFBRSxxQ0FBcUM7SUFDOUMsUUFBUSxFQUFFLGFBQWE7Q0FDMUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBLYnFDbGFtcGVkVGV4dExvY2FsZUNvbmZpZywgcnVSVUxvY2FsZURhdGEgfSBmcm9tICdAa29vYmlxL2NvbXBvbmVudHMvY29yZSc7XG5cbi8qKlxuICogRGVmYXVsdCBtYXhpbXVtIG51bWJlciBvZiB2aXNpYmxlIHJvd3MgZm9yIHRoZSBjbGFtcGVkIHRleHQgY29tcG9uZW50XG4gKiBiZWZvcmUgdHJ1bmNhdGlvbiBhbmQgdGhlIFwiY29sbGFwc2UvZXhwYW5kXCIgdG9nZ2xlIGlzIHNob3duLlxuICovXG5leHBvcnQgY29uc3Qga2JxQ2xhbXBlZFRleHREZWZhdWx0TWF4Um93cyA9IDU7XG5cbi8qKiBMb2NhbGl6YXRpb24gY29uZmlndXJhdGlvbiBwcm92aWRlci4gKi9cbmV4cG9ydCBjb25zdCBLQlFfQ0xBTVBFRF9URVhUX0xPQ0FMRV9DT05GSUdVUkFUSU9OID0gbmV3IEluamVjdGlvblRva2VuPEticUNsYW1wZWRUZXh0TG9jYWxlQ29uZmlnPihcbiAgICAnS2JxQ2xhbXBlZFRleHRMb2NhbGVDb25maWcnLFxuICAgIHtcbiAgICAgICAgZmFjdG9yeTogKCkgPT4gcnVSVUxvY2FsZURhdGEuY2xhbXBlZFRleHRcbiAgICB9XG4pO1xuXG4vKipcbiAqIFV0aWxpdHkgcHJvdmlkZXIuXG4gKiBAc2VlIEtCUV9DTEFNUEVEX1RFWFRfTE9DQUxFX0NPTkZJR1VSQVRJT05cbiAqL1xuZXhwb3J0IGNvbnN0IGticUNsYW1wZWRUZXh0TG9jYWxlQ29uZmlndXJhdGlvblByb3ZpZGVyID0gKGNvbmZpZ3VyYXRpb246IEticUNsYW1wZWRUZXh0TG9jYWxlQ29uZmlnKTogUHJvdmlkZXIgPT4gKHtcbiAgICBwcm92aWRlOiBLQlFfQ0xBTVBFRF9URVhUX0xPQ0FMRV9DT05GSUdVUkFUSU9OLFxuICAgIHVzZVZhbHVlOiBjb25maWd1cmF0aW9uXG59KTtcbiJdfQ==

package/esm2022/clamped-text/index.mjs

@@ -0,0 +1,4 @@
+export * from './clamped-text';
+export * from './constants';
+export * from './module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21wb25lbnRzL2NsYW1wZWQtdGV4dC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGFtcGVkLXRleHQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUnO1xuIl19

package/esm2022/clamped-text/koobiq-components-clamped-text.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29vYmlxLWNvbXBvbmVudHMtY2xhbXBlZC10ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcG9uZW50cy9jbGFtcGVkLXRleHQva29vYmlxLWNvbXBvbmVudHMtY2xhbXBlZC10ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/clamped-text/module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { KbqClampedText } from './clamped-text';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    KbqClampedText
+];
+export class KbqClampedTextModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedTextModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedTextModule, imports: [KbqClampedText], exports: [KbqClampedText] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedTextModule, imports: [COMPONENTS] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KbqClampedTextModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcG9uZW50cy9jbGFtcGVkLXRleHQvbW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQUVoRCxNQUFNLFVBQVUsR0FBRztJQUNmLGNBQWM7Q0FDakIsQ0FBQztBQU1GLE1BQU0sT0FBTyxvQkFBb0I7a0lBQXBCLG9CQUFvQjttSUFBcEIsb0JBQW9CLFlBUDdCLGNBQWMsYUFBZCxjQUFjO21JQU9MLG9CQUFvQixZQUhwQixVQUFVOzs0RkFHVixvQkFBb0I7a0JBSmhDLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLFVBQVU7b0JBQ25CLE9BQU8sRUFBRSxVQUFVO2lCQUN0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBLYnFDbGFtcGVkVGV4dCB9IGZyb20gJy4vY2xhbXBlZC10ZXh0JztcblxuY29uc3QgQ09NUE9ORU5UUyA9IFtcbiAgICBLYnFDbGFtcGVkVGV4dFxuXTtcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBDT01QT05FTlRTLFxuICAgIGV4cG9ydHM6IENPTVBPTkVOVFNcbn0pXG5leHBvcnQgY2xhc3MgS2JxQ2xhbXBlZFRleHRNb2R1bGUge31cbiJdfQ==