@radix-ng/primitives 0.17.0 → 0.18.0

package/esm2022/slider/src/utils.mjs

@@ -0,0 +1,94 @@
+// https://github.com/tmcw-up-for-adoption/simple-linear-scale/blob/master/index.js
+export function linearScale(input, output) {
+    return (value) => {
+        if (input[0] === input[1] || output[0] === output[1])
+            return output[0];
+        const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+        return output[0] + ratio * (value - input[0]);
+    };
+}
+/**
+ * Verifies the minimum steps between all values is greater than or equal
+ * to the expected minimum steps.
+ *
+ * @example
+ * // returns false
+ * hasMinStepsBetweenValues([1,2,3], 2);
+ *
+ * @example
+ * // returns true
+ * hasMinStepsBetweenValues([1,2,3], 1);
+ */
+export function hasMinStepsBetweenValues(values, minStepsBetweenValues) {
+    if (minStepsBetweenValues > 0) {
+        const stepsBetweenValues = getStepsBetweenValues(values);
+        const actualMinStepsBetweenValues = Math.min(...stepsBetweenValues);
+        return actualMinStepsBetweenValues >= minStepsBetweenValues;
+    }
+    return true;
+}
+/**
+ * Given a `values` array and a `nextValue`, determine which value in
+ * the array is closest to `nextValue` and return its index.
+ *
+ * @example
+ * // returns 1
+ * getClosestValueIndex([10, 30], 25);
+ */
+export function getClosestValueIndex(values, nextValue) {
+    if (values.length === 1)
+        return 0;
+    const distances = values.map((value) => Math.abs(value - nextValue));
+    const closestDistance = Math.min(...distances);
+    return distances.indexOf(closestDistance);
+}
+/**
+ * Gets an array of steps between each value.
+ *
+ * @example
+ * // returns [1, 9]
+ * getStepsBetweenValues([10, 11, 20]);
+ */
+export function getStepsBetweenValues(values) {
+    return values.slice(0, -1).map((value, index) => values[index + 1] - value);
+}
+/**
+ * Offsets the thumb centre point while sliding to ensure it remains
+ * within the bounds of the slider when reaching the edges
+ */
+export function getThumbInBoundsOffset(width, left, direction) {
+    const halfWidth = width / 2;
+    const halfPercent = 50;
+    const offset = linearScale([0, halfPercent], [0, halfWidth]);
+    return (halfWidth - offset(left) * direction) * direction;
+}
+export function convertValueToPercentage(value, min, max) {
+    const maxSteps = max - min;
+    const percentPerStep = 100 / maxSteps;
+    const percentage = percentPerStep * (value - min);
+    return clamp(percentage, 0, 100);
+}
+export function getDecimalCount(value) {
+    return (String(value).split('.')[1] || '').length;
+}
+export function roundValue(value, decimalCount) {
+    const rounder = 10 ** decimalCount;
+    return Math.round(value * rounder) / rounder;
+}
+export function getNextSortedValues(prevValues = [], nextValue, atIndex) {
+    const nextValues = [...prevValues];
+    nextValues[atIndex] = nextValue;
+    return nextValues.sort((a, b) => a - b);
+}
+export const PAGE_KEYS = ['PageUp', 'PageDown'];
+export const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
+export const BACK_KEYS = {
+    'from-left': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],
+    'from-right': ['Home', 'PageDown', 'ArrowDown', 'ArrowRight'],
+    'from-bottom': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],
+    'from-top': ['Home', 'PageDown', 'ArrowUp', 'ArrowLeft']
+};
+export function clamp(value, min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY) {
+    return Math.min(Math.max(value, min), max);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../packages/primitives/slider/src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/tmcw-up-for-adoption/simple-linear-scale/blob/master/index.js\nexport function linearScale(input: readonly [number, number], output: readonly [number, number]) {\n    return (value: number) => {\n        if (input[0] === input[1] || output[0] === output[1]) return output[0];\n        const ratio = (output[1] - output[0]) / (input[1] - input[0]);\n        return output[0] + ratio * (value - input[0]);\n    };\n}\n\n/**\n * Verifies the minimum steps between all values is greater than or equal\n * to the expected minimum steps.\n *\n * @example\n * // returns false\n * hasMinStepsBetweenValues([1,2,3], 2);\n *\n * @example\n * // returns true\n * hasMinStepsBetweenValues([1,2,3], 1);\n */\nexport function hasMinStepsBetweenValues(values: number[], minStepsBetweenValues: number) {\n    if (minStepsBetweenValues > 0) {\n        const stepsBetweenValues = getStepsBetweenValues(values);\n        const actualMinStepsBetweenValues = Math.min(...stepsBetweenValues);\n        return actualMinStepsBetweenValues >= minStepsBetweenValues;\n    }\n    return true;\n}\n\n/**\n * Given a `values` array and a `nextValue`, determine which value in\n * the array is closest to `nextValue` and return its index.\n *\n * @example\n * // returns 1\n * getClosestValueIndex([10, 30], 25);\n */\nexport function getClosestValueIndex(values: number[], nextValue: number) {\n    if (values.length === 1) return 0;\n    const distances = values.map((value) => Math.abs(value - nextValue));\n    const closestDistance = Math.min(...distances);\n    return distances.indexOf(closestDistance);\n}\n\n/**\n * Gets an array of steps between each value.\n *\n * @example\n * // returns [1, 9]\n * getStepsBetweenValues([10, 11, 20]);\n */\nexport function getStepsBetweenValues(values: number[]) {\n    return values.slice(0, -1).map((value, index) => values[index + 1] - value);\n}\n\n/**\n * Offsets the thumb centre point while sliding to ensure it remains\n * within the bounds of the slider when reaching the edges\n */\nexport function getThumbInBoundsOffset(width: number, left: number, direction: number) {\n    const halfWidth = width / 2;\n    const halfPercent = 50;\n    const offset = linearScale([0, halfPercent], [0, halfWidth]);\n    return (halfWidth - offset(left) * direction) * direction;\n}\n\nexport function convertValueToPercentage(value: number, min: number, max: number) {\n    const maxSteps = max - min;\n    const percentPerStep = 100 / maxSteps;\n    const percentage = percentPerStep * (value - min);\n    return clamp(percentage, 0, 100);\n}\n\nexport function getDecimalCount(value: number) {\n    return (String(value).split('.')[1] || '').length;\n}\n\nexport function roundValue(value: number, decimalCount: number) {\n    const rounder = 10 ** decimalCount;\n    return Math.round(value * rounder) / rounder;\n}\n\nexport function getNextSortedValues(prevValues: number[] = [], nextValue: number, atIndex: number) {\n    const nextValues = [...prevValues];\n    nextValues[atIndex] = nextValue;\n    return nextValues.sort((a, b) => a - b);\n}\n\nexport const PAGE_KEYS = ['PageUp', 'PageDown'];\nexport const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];\n\ntype SlideDirection = 'from-left' | 'from-right' | 'from-bottom' | 'from-top';\nexport const BACK_KEYS: Record<SlideDirection, string[]> = {\n    'from-left': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],\n    'from-right': ['Home', 'PageDown', 'ArrowDown', 'ArrowRight'],\n    'from-bottom': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],\n    'from-top': ['Home', 'PageDown', 'ArrowUp', 'ArrowLeft']\n};\n\nexport interface OrientationContext {\n    direction: number;\n    size: 'width' | 'height';\n    startEdge: 'left' | 'top';\n    endEdge: 'right' | 'bottom';\n}\n\nexport function clamp(\n    value: number,\n    min: number = Number.NEGATIVE_INFINITY,\n    max: number = Number.POSITIVE_INFINITY\n): number {\n    return Math.min(Math.max(value, min), max);\n}\n"]}

package/esm2022/tooltip/index.mjs

@@ -0,0 +1,41 @@
+import { NgModule } from '@angular/core';
+import { RdxTooltipArrowDirective } from './src/tooltip-arrow.directive';
+import { RdxTooltipContentAttributesDirective } from './src/tooltip-content-attributes.directive';
+import { RdxTooltipContentDirective } from './src/tooltip-content.directive';
+import { RdxTooltipRootDirective } from './src/tooltip-root.directive';
+import { RdxTooltipTriggerDirective } from './src/tooltip-trigger.directive';
+import * as i0 from "@angular/core";
+export * from './src/tooltip-arrow.directive';
+export * from './src/tooltip-content-attributes.directive';
+export * from './src/tooltip-content.directive';
+export * from './src/tooltip-root.directive';
+export * from './src/tooltip-trigger.directive';
+export * from './src/tooltip.types';
+const _imports = [
+    RdxTooltipArrowDirective,
+    RdxTooltipContentDirective,
+    RdxTooltipTriggerDirective,
+    RdxTooltipContentAttributesDirective,
+    RdxTooltipRootDirective
+];
+export class RdxTooltipModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipModule, imports: [RdxTooltipArrowDirective,
+            RdxTooltipContentDirective,
+            RdxTooltipTriggerDirective,
+            RdxTooltipContentAttributesDirective,
+            RdxTooltipRootDirective], exports: [RdxTooltipArrowDirective,
+            RdxTooltipContentDirective,
+            RdxTooltipTriggerDirective,
+            RdxTooltipContentAttributesDirective,
+            RdxTooltipRootDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [..._imports],
+                    exports: [..._imports]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tooltip/radix-ng-primitives-tooltip.mjs

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

package/esm2022/tooltip/src/get-content-position.mjs

@@ -0,0 +1,31 @@
+import { TOOLTIP_POSITIONS } from './tooltip.constants';
+import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+export function getContentPosition(side, align, sideOffset, alignOffset) {
+    const position = TOOLTIP_POSITIONS[side][align] ?? TOOLTIP_POSITIONS[RdxTooltipSide.Top][RdxTooltipAlign.Center];
+    if (sideOffset > 0) {
+        let xFactor = 0;
+        let yFactor = 0;
+        switch (side) {
+            case RdxTooltipSide.Top:
+                yFactor = -1;
+                break;
+            case RdxTooltipSide.Bottom:
+                yFactor = 1;
+                break;
+            case RdxTooltipSide.Left:
+                xFactor = -1;
+                break;
+            case RdxTooltipSide.Right:
+                xFactor = 1;
+                break;
+        }
+        position.offsetX = xFactor * sideOffset;
+        position.offsetY = yFactor * sideOffset;
+    }
+    if ([RdxTooltipAlign.Start, RdxTooltipAlign.End].includes(align) && alignOffset) {
+        const alignOffsetFactor = align === RdxTooltipAlign.End ? -1 : 1;
+        position.offsetX = alignOffsetFactor * alignOffset;
+    }
+    return position;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tooltip/src/tooltip-arrow.directive.mjs

@@ -0,0 +1,92 @@
+import { computed, Directive, effect, ElementRef, forwardRef, inject, input, Renderer2 } from '@angular/core';
+import { RdxTooltipArrowToken } from './tooltip-arrow.token';
+import { RdxTooltipContentToken } from './tooltip-content.token';
+import { RdxTooltipSide } from './tooltip.types';
+import * as i0 from "@angular/core";
+export class RdxTooltipArrowDirective {
+    constructor() {
+        /** @ignore */
+        this.renderer = inject(Renderer2);
+        /** @ignore */
+        this.contentDirective = inject(RdxTooltipContentToken);
+        /** @ignore */
+        this.elementRef = inject(ElementRef);
+        /**
+         * The width of the arrow in pixels.
+         */
+        this.width = input(10);
+        /**
+         * The height of the arrow in pixels.
+         */
+        this.height = input(5);
+        /** @ignore */
+        this.arrowSvgElement = computed(() => {
+            const width = this.width();
+            const height = this.height();
+            const svgElement = this.renderer.createElement('svg', 'svg');
+            this.renderer.setAttribute(svgElement, 'viewBox', '0 0 30 10');
+            this.renderer.setAttribute(svgElement, 'width', String(width));
+            this.renderer.setAttribute(svgElement, 'height', String(height));
+            const polygonElement = this.renderer.createElement('polygon', 'svg');
+            this.renderer.setAttribute(polygonElement, 'points', '0,0 30,0 15,10');
+            this.renderer.setAttribute(svgElement, 'preserveAspectRatio', 'none');
+            this.renderer.appendChild(svgElement, polygonElement);
+            return svgElement;
+        });
+        /** @ignore */
+        this.onArrowSvgElementChangeEffect = effect(() => {
+            const arrowElement = this.arrowSvgElement();
+            this.renderer.appendChild(this.elementRef.nativeElement, arrowElement);
+        });
+        /** @ignore */
+        this.onSideChangeEffect = effect(() => {
+            const side = this.contentDirective.side();
+            this.elementRef.nativeElement.parentElement?.setAttribute('style', `position: relative;`);
+            this.elementRef.nativeElement.style.position = 'absolute';
+            this.elementRef.nativeElement.style.boxSizing = '';
+            this.elementRef.nativeElement.style.width = `${this.width()}px`;
+            this.elementRef.nativeElement.style.height = `${this.height()}px`;
+            this.elementRef.nativeElement.style.fontSize = '0px';
+            if ([RdxTooltipSide.Top, RdxTooltipSide.Bottom].includes(side)) {
+                this.elementRef.nativeElement.style.left = `calc(50% - ${this.width() / 2}px)`;
+                this.elementRef.nativeElement.style.top = '100%';
+                if (side === RdxTooltipSide.Bottom) {
+                    this.elementRef.nativeElement.style.transform = 'rotate(180deg)';
+                    this.elementRef.nativeElement.style.top = `-${this.height()}px`;
+                }
+            }
+            if ([RdxTooltipSide.Left, RdxTooltipSide.Right].includes(side)) {
+                this.elementRef.nativeElement.style.top = `calc(50% - ${this.height() / 2}px)`;
+                if (side === RdxTooltipSide.Left) {
+                    this.elementRef.nativeElement.style.left = `100%`;
+                    this.elementRef.nativeElement.style.transform = 'rotate(-90deg) translate(0, -50%)';
+                }
+                if (side === RdxTooltipSide.Right) {
+                    this.elementRef.nativeElement.style.right = `100%`;
+                    this.elementRef.nativeElement.style.transform = 'rotate(90deg) translate(0, -50%)';
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipArrowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxTooltipArrowDirective, isStandalone: true, selector: "[rdxTooltipArrow]", inputs: { width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: RdxTooltipArrowToken,
+                useExisting: forwardRef(() => RdxTooltipArrowDirective)
+            }
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipArrowDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxTooltipArrow]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: RdxTooltipArrowToken,
+                            useExisting: forwardRef(() => RdxTooltipArrowDirective)
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip-arrow.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/tooltip/src/tooltip-arrow.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, Directive, effect, ElementRef, forwardRef, inject, input, Renderer2 } from '@angular/core';\nimport { RdxTooltipArrowToken } from './tooltip-arrow.token';\nimport { RdxTooltipContentToken } from './tooltip-content.token';\nimport { RdxTooltipSide } from './tooltip.types';\n\n@Directive({\n    selector: '[rdxTooltipArrow]',\n    standalone: true,\n    providers: [\n        {\n            provide: RdxTooltipArrowToken,\n            useExisting: forwardRef(() => RdxTooltipArrowDirective)\n        }\n    ]\n})\nexport class RdxTooltipArrowDirective {\n    /** @ignore */\n    private readonly renderer = inject(Renderer2);\n    /** @ignore */\n    private readonly contentDirective = inject(RdxTooltipContentToken);\n    /** @ignore */\n    private readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n\n    /**\n     * The width of the arrow in pixels.\n     */\n    readonly width = input<number>(10);\n\n    /**\n     * The height of the arrow in pixels.\n     */\n    readonly height = input<number>(5);\n\n    /** @ignore */\n    readonly arrowSvgElement = computed<HTMLElement>(() => {\n        const width = this.width();\n        const height = this.height();\n\n        const svgElement = this.renderer.createElement('svg', 'svg');\n        this.renderer.setAttribute(svgElement, 'viewBox', '0 0 30 10');\n        this.renderer.setAttribute(svgElement, 'width', String(width));\n        this.renderer.setAttribute(svgElement, 'height', String(height));\n        const polygonElement = this.renderer.createElement('polygon', 'svg');\n        this.renderer.setAttribute(polygonElement, 'points', '0,0 30,0 15,10');\n        this.renderer.setAttribute(svgElement, 'preserveAspectRatio', 'none');\n        this.renderer.appendChild(svgElement, polygonElement);\n\n        return svgElement;\n    });\n\n    /** @ignore */\n    private readonly onArrowSvgElementChangeEffect = effect(() => {\n        const arrowElement = this.arrowSvgElement();\n\n        this.renderer.appendChild(this.elementRef.nativeElement, arrowElement);\n    });\n\n    /** @ignore */\n    private readonly onSideChangeEffect = effect(() => {\n        const side = this.contentDirective.side();\n\n        this.elementRef.nativeElement.parentElement?.setAttribute('style', `position: relative;`);\n        this.elementRef.nativeElement.style.position = 'absolute';\n        this.elementRef.nativeElement.style.boxSizing = '';\n        this.elementRef.nativeElement.style.width = `${this.width()}px`;\n        this.elementRef.nativeElement.style.height = `${this.height()}px`;\n        this.elementRef.nativeElement.style.fontSize = '0px';\n\n        if ([RdxTooltipSide.Top, RdxTooltipSide.Bottom].includes(side)) {\n            this.elementRef.nativeElement.style.left = `calc(50% - ${this.width() / 2}px)`;\n            this.elementRef.nativeElement.style.top = '100%';\n\n            if (side === RdxTooltipSide.Bottom) {\n                this.elementRef.nativeElement.style.transform = 'rotate(180deg)';\n                this.elementRef.nativeElement.style.top = `-${this.height()}px`;\n            }\n        }\n\n        if ([RdxTooltipSide.Left, RdxTooltipSide.Right].includes(side)) {\n            this.elementRef.nativeElement.style.top = `calc(50% - ${this.height() / 2}px)`;\n\n            if (side === RdxTooltipSide.Left) {\n                this.elementRef.nativeElement.style.left = `100%`;\n                this.elementRef.nativeElement.style.transform = 'rotate(-90deg) translate(0, -50%)';\n            }\n\n            if (side === RdxTooltipSide.Right) {\n                this.elementRef.nativeElement.style.right = `100%`;\n                this.elementRef.nativeElement.style.transform = 'rotate(90deg) translate(0, -50%)';\n            }\n        }\n    });\n}\n"]}

package/esm2022/tooltip/src/tooltip-arrow.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const RdxTooltipArrowToken = new InjectionToken('RdxTooltipArrowToken');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1hcnJvdy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvdG9vbHRpcC9zcmMvdG9vbHRpcC1hcnJvdy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUEyQixzQkFBc0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJkeFRvb2x0aXBBcnJvd0RpcmVjdGl2ZSB9IGZyb20gJy4vdG9vbHRpcC1hcnJvdy5kaXJlY3RpdmUnO1xuXG5leHBvcnQgY29uc3QgUmR4VG9vbHRpcEFycm93VG9rZW4gPSBuZXcgSW5qZWN0aW9uVG9rZW48UmR4VG9vbHRpcEFycm93RGlyZWN0aXZlPignUmR4VG9vbHRpcEFycm93VG9rZW4nKTtcbiJdfQ==

package/esm2022/tooltip/src/tooltip-content-attributes.directive.mjs

@@ -0,0 +1,24 @@
+import { Directive, inject } from '@angular/core';
+import { RdxTooltipContentToken } from './tooltip-content.token';
+import { RdxTooltipRootDirective } from './tooltip-root.directive';
+import * as i0 from "@angular/core";
+export class RdxTooltipContentAttributesDirective {
+    constructor() {
+        this.tooltipRoot = inject(RdxTooltipRootDirective);
+        this.tooltipContent = inject(RdxTooltipContentToken);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipContentAttributesDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxTooltipContentAttributesDirective, isStandalone: true, selector: "[rdxTooltipContentAttributes]", host: { properties: { "attr.data-state": "tooltipRoot.state()", "attr.data-side": "tooltipContent.side()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipContentAttributesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxTooltipContentAttributes]',
+                    standalone: true,
+                    host: {
+                        '[attr.data-state]': 'tooltipRoot.state()',
+                        '[attr.data-side]': 'tooltipContent.side()'
+                    }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1jb250ZW50LWF0dHJpYnV0ZXMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy90b29sdGlwL3NyYy90b29sdGlwLWNvbnRlbnQtYXR0cmlidXRlcy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7O0FBVW5FLE1BQU0sT0FBTyxvQ0FBb0M7SUFSakQ7UUFTYSxnQkFBVyxHQUFHLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO1FBQzlDLG1CQUFjLEdBQUcsTUFBTSxDQUFDLHNCQUFzQixDQUFDLENBQUM7S0FDNUQ7K0dBSFksb0NBQW9DO21HQUFwQyxvQ0FBb0M7OzRGQUFwQyxvQ0FBb0M7a0JBUmhELFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLCtCQUErQjtvQkFDekMsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLElBQUksRUFBRTt3QkFDRixtQkFBbUIsRUFBRSxxQkFBcUI7d0JBQzFDLGtCQUFrQixFQUFFLHVCQUF1QjtxQkFDOUM7aUJBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUmR4VG9vbHRpcENvbnRlbnRUb2tlbiB9IGZyb20gJy4vdG9vbHRpcC1jb250ZW50LnRva2VuJztcbmltcG9ydCB7IFJkeFRvb2x0aXBSb290RGlyZWN0aXZlIH0gZnJvbSAnLi90b29sdGlwLXJvb3QuZGlyZWN0aXZlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbcmR4VG9vbHRpcENvbnRlbnRBdHRyaWJ1dGVzXScsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBob3N0OiB7XG4gICAgICAgICdbYXR0ci5kYXRhLXN0YXRlXSc6ICd0b29sdGlwUm9vdC5zdGF0ZSgpJyxcbiAgICAgICAgJ1thdHRyLmRhdGEtc2lkZV0nOiAndG9vbHRpcENvbnRlbnQuc2lkZSgpJ1xuICAgIH1cbn0pXG5leHBvcnQgY2xhc3MgUmR4VG9vbHRpcENvbnRlbnRBdHRyaWJ1dGVzRGlyZWN0aXZlIHtcbiAgICByZWFkb25seSB0b29sdGlwUm9vdCA9IGluamVjdChSZHhUb29sdGlwUm9vdERpcmVjdGl2ZSk7XG4gICAgcmVhZG9ubHkgdG9vbHRpcENvbnRlbnQgPSBpbmplY3QoUmR4VG9vbHRpcENvbnRlbnRUb2tlbik7XG59XG4iXX0=

package/esm2022/tooltip/src/tooltip-content.directive.mjs

@@ -0,0 +1,48 @@
+import { computed, Directive, forwardRef, inject, input, output, TemplateRef } from '@angular/core';
+import { getContentPosition } from './get-content-position';
+import { RdxTooltipContentToken } from './tooltip-content.token';
+import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+import * as i0 from "@angular/core";
+export class RdxTooltipContentDirective {
+    constructor() {
+        /** @ignore */
+        this.templateRef = inject(TemplateRef);
+        /**
+         * The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+         */
+        this.side = input(RdxTooltipSide.Top);
+        /**
+         * The distance in pixels from the trigger.
+         */
+        this.sideOffset = input(0);
+        /**
+         * The preferred alignment against the trigger. May change when collisions occur.
+         */
+        this.align = input(RdxTooltipAlign.Center);
+        /**
+         * An offset in pixels from the "start" or "end" alignment options.
+         */
+        this.alignOffset = input(0);
+        /** @ingore */
+        this.position = computed(() => getContentPosition(this.side(), this.align(), this.sideOffset(), this.alignOffset()));
+        /**
+         * Event handler called when the escape key is down. It can be prevented by calling event.preventDefault.
+         */
+        this.onEscapeKeyDown = output();
+        /**
+         * Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling event.preventDefault.
+         */
+        this.onPointerDownOutside = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxTooltipContentDirective, isStandalone: true, selector: "[rdxTooltipContent]", inputs: { side: { classPropertyName: "side", publicName: "side", isSignal: true, isRequired: false, transformFunction: null }, sideOffset: { classPropertyName: "sideOffset", publicName: "sideOffset", isSignal: true, isRequired: false, transformFunction: null }, align: { classPropertyName: "align", publicName: "align", isSignal: true, isRequired: false, transformFunction: null }, alignOffset: { classPropertyName: "alignOffset", publicName: "alignOffset", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onEscapeKeyDown: "onEscapeKeyDown", onPointerDownOutside: "onPointerDownOutside" }, providers: [{ provide: RdxTooltipContentToken, useExisting: forwardRef(() => RdxTooltipContentDirective) }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxTooltipContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxTooltipContent]',
+                    standalone: true,
+                    providers: [{ provide: RdxTooltipContentToken, useExisting: forwardRef(() => RdxTooltipContentDirective) }]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tooltip/src/tooltip-content.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const RdxTooltipContentToken = new InjectionToken('RdxTooltipContentToken');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1jb250ZW50LnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy90b29sdGlwL3NyYy90b29sdGlwLWNvbnRlbnQudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQyxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLGNBQWMsQ0FBNkIsd0JBQXdCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZHhUb29sdGlwQ29udGVudERpcmVjdGl2ZSB9IGZyb20gJy4vdG9vbHRpcC1jb250ZW50LmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBSZHhUb29sdGlwQ29udGVudFRva2VuID0gbmV3IEluamVjdGlvblRva2VuPFJkeFRvb2x0aXBDb250ZW50RGlyZWN0aXZlPignUmR4VG9vbHRpcENvbnRlbnRUb2tlbicpO1xuIl19