@piwitests/server 0.25.0 → 0.26.0

package/.output/server/node_modules/@unovis/ts/components/axis/index.js

@@ -1,500 +0,0 @@
-import { select } from 'd3-selection';
-import { interrupt } from 'd3-transition';
-import { axisLeft, axisRight, axisBottom, axisTop } from 'd3-axis';
-import { XYComponentCore } from '../../core/xy-component/index.js';
-import { Position } from '../../types/position.js';
-import { VerticalAlign, FitMode, TextAlign } from '../../types/text.js';
-import { smartTransition } from '../../utils/d3.js';
-import { trimSVGText, renderTextToSvgTextElement, wrapSVGText, textAlignToAnchor } from '../../utils/text.js';
-import { isEqual, isFunction } from '../../utils/data.js';
-import { rectIntersect } from '../../utils/misc.js';
-import { getFontWidthToHeightRatio } from '../../styles/index.js';
-import { AxisType } from './types.js';
-import { AxisDefaultConfig } from './config.js';
-import * as style from './style.js';
-import { grid, tick, tickLabel, tickLabelHideable, tickTextExiting, axis, hideTickLine, hideDomain, label } from './style.js';
-
-class Axis extends XYComponentCore {
-    constructor(config) {
-        super();
-        this._defaultConfig = AxisDefaultConfig;
-        this.config = this._defaultConfig;
-        this._defaultNumTicks = 3;
-        this.events = {};
-        if (config)
-            this.setConfig(config);
-        this.g.attr('axis-type', this.config.type);
-        this.axisGroup = this.g.append('g');
-        this.gridGroup = this.g.append('g')
-            .attr('class', grid);
-    }
-    /** Renders axis to an invisible grouped to calculate automatic chart margins */
-    preRender() {
-        const { config } = this;
-        const axisRenderHelperGroup = this.g.append('g').attr('opacity', 0);
-        this._renderAxis(axisRenderHelperGroup, 0);
-        // Align tick text
-        if (config.tickTextAlign)
-            this._alignTickLabels(axisRenderHelperGroup);
-        // Store axis raw BBox (without the label) for further label positioning (see _renderAxisLabel)
-        this._axisRawBBox = axisRenderHelperGroup.node().getBBox();
-        // Render label and store total axis size and required margins
-        this._renderAxisLabel(axisRenderHelperGroup);
-        this._axisSizeBBox = this._getAxisSize(axisRenderHelperGroup);
-        this._requiredMargin = this._getRequiredMargin(this._axisSizeBBox);
-        axisRenderHelperGroup.remove();
-    }
-    getPosition() {
-        const { config: { type, position } } = this;
-        return (position !== null && position !== void 0 ? position : ((type === AxisType.X) ? Position.Bottom : Position.Left));
-    }
-    _getAxisSize(selection) {
-        const bBox = selection.node().getBBox();
-        return bBox;
-    }
-    _getRequiredMargin(axisSize = this._axisSizeBBox) {
-        const { config: { type, position } } = this;
-        switch (type) {
-            case AxisType.X: {
-                const tolerancePx = 1;
-                const xEnd = this._axisSizeBBox.x + this._axisSizeBBox.width;
-                const left = this._axisSizeBBox.x < 0 ? Math.abs(this._axisSizeBBox.x) : 0;
-                const right = (xEnd - this._width) > tolerancePx ? xEnd - this._width : 0;
-                switch (position) {
-                    case Position.Top: return { top: axisSize.height, left, right };
-                    case Position.Bottom:
-                    default: return { bottom: axisSize.height, left, right };
-                }
-            }
-            case AxisType.Y: {
-                const bleedY = axisSize.height > this._height ? (axisSize.height - this._height) / 2 : 0;
-                const top = bleedY;
-                const bottom = bleedY;
-                switch (position) {
-                    case Position.Right: return { right: axisSize.width, top, bottom };
-                    case Position.Left:
-                    default: return { left: axisSize.width, top, bottom };
-                }
-            }
-        }
-    }
-    getRequiredMargin() {
-        return this._requiredMargin;
-    }
-    /** Calculates axis transform:translate offset based on passed container margins */
-    getOffset(containerMargin) {
-        const { config: { type, position } } = this;
-        switch (type) {
-            case AxisType.X:
-                switch (position) {
-                    case Position.Top: return { top: containerMargin.top, left: containerMargin.left };
-                    case Position.Bottom:
-                    default: return { top: containerMargin.top + this._height, left: containerMargin.left };
-                }
-            case AxisType.Y:
-                switch (position) {
-                    case Position.Right: return { top: containerMargin.top, left: containerMargin.left + this._width };
-                    case Position.Left:
-                    default: return { top: containerMargin.top, left: containerMargin.left };
-                }
-        }
-    }
-    _render(duration = this.config.duration, selection = this.axisGroup) {
-        const { config } = this;
-        this._renderAxis(selection, duration);
-        this._renderAxisLabel(selection);
-        if (config.gridLine) {
-            const gridGen = this._buildGrid();
-            // Interrupting all active transitions first to prevent them from being stuck.
-            // Somehow we see it happening in Angular apps.
-            this.gridGroup.selectAll('*').interrupt();
-            smartTransition(this.gridGroup, duration).call(gridGen).style('opacity', 1);
-        }
-        else {
-            smartTransition(this.gridGroup, duration).style('opacity', 0);
-        }
-        if (config.tickTextAlign)
-            this._alignTickLabels();
-        this._resolveTickLabelOverlap(selection);
-    }
-    _getAxisGen() {
-        const { config } = this;
-        switch (config.type) {
-            case AxisType.X:
-                switch (config.position) {
-                    case Position.Top: return axisTop(this.xScale);
-                    case Position.Bottom:
-                    default: return axisBottom(this.xScale);
-                }
-            case AxisType.Y:
-                switch (config.position) {
-                    case Position.Right: return axisRight(this.yScale);
-                    case Position.Left:
-                    default: return axisLeft(this.yScale);
-                }
-        }
-    }
-    _buildAxis() {
-        const { config: { tickPadding, tickSize } } = this;
-        const tickSizeInner = Array.isArray(tickSize) ? tickSize[0] : tickSize;
-        const tickSizeOuter = Array.isArray(tickSize) ? tickSize[1] : tickSize;
-        const ticks = this._getNumTicks();
-        const axisGen = this._getAxisGen();
-        axisGen.ticks(ticks).tickPadding(tickPadding).tickSizeInner(tickSizeInner).tickSizeOuter(tickSizeOuter);
-        return axisGen;
-    }
-    _buildGrid() {
-        const { config } = this;
-        const gridGen = this._getAxisGen();
-        gridGen
-            .tickSize(config.type === AxisType.X ? -this._height : -this._width)
-            .tickSizeOuter(0)
-            .tickFormat(() => '');
-        const numTicks = this._getNumTicks() * 2;
-        const gridScale = gridGen.scale();
-        const scaleDomain = gridScale.domain();
-        const getGridMinMaxTicksOnlyValues = () => {
-            if (!config.minMaxTicksOnlyShowGridLines)
-                return scaleDomain;
-            const tickValues = gridScale.ticks(numTicks);
-            if (tickValues.length < 2)
-                return scaleDomain;
-            // If the last tick is far enough from the domain max value, we add it to the tick values to draw the grid line
-            const tickValuesStep = +tickValues[1] - +tickValues[0];
-            const domainMaxValue = scaleDomain[1];
-            const diff = +domainMaxValue - +tickValues[tickValues.length - 1];
-            return diff > tickValuesStep / 2 ? [...tickValues, domainMaxValue] : tickValues;
-        };
-        const tickValues = config.tickValues
-            ? this._getConfiguredTickValues()
-            : this._shouldRenderMinMaxTicksOnly()
-                ? getGridMinMaxTicksOnlyValues()
-                : gridScale.ticks(numTicks);
-        gridGen.tickValues(tickValues);
-        return gridGen;
-    }
-    _renderAxis(selection = this.axisGroup, duration = this.config.duration) {
-        const { config } = this;
-        const axisGen = this._buildAxis();
-        const axisScale = axisGen.scale();
-        const tickValues = config.tickValues
-            ? this._getConfiguredTickValues()
-            : this._shouldRenderMinMaxTicksOnly()
-                ? axisScale.domain()
-                : axisScale.ticks(this._getNumTicks());
-        const tickCount = tickValues.length;
-        axisGen.tickValues(tickValues);
-        // Interrupting all active transitions first to prevent them from being stuck.
-        // Somehow we see it happening in Angular apps.
-        selection.selectAll('*').interrupt();
-        const transition = smartTransition(selection, duration).call(axisGen);
-        // Unset D3's default y and dy attributes because we're going to set them manually in the renderTextToSvgTextElement function
-        selection.selectAll('text')
-            .attr('dy', null)
-            .attr('y', null);
-        // Resolving tick label overlap after the animation is over
-        transition.on('end', () => {
-            this._resolveTickLabelOverlap(selection);
-        });
-        const ticks = selection.selectAll('g.tick');
-        ticks
-            .classed(tick, true)
-            .style('font-size', config.tickTextFontSize);
-        // Selecting the <text> elements of the ticks to apply formatting. By default, this selection
-        // will include exiting elements, so we're filtering them out.
-        const tickText = selection.selectAll('g.tick > text')
-            .filter(tickValue => tickValues.some((t) => isEqual(tickValue, t))) // We use isEqual to compare Dates
-            .classed(tickLabel, true)
-            .classed(tickLabelHideable, Boolean(config.tickTextHideOverlapping))
-            .classed(tickTextExiting, false)
-            .style('fill', config.tickTextColor);
-        // Marking exiting elements
-        selection.selectAll('g.tick > text')
-            .filter(tickValue => !tickValues.some((t) => isEqual(tickValue, t)))
-            .classed(tickTextExiting, true);
-        // We interrupt the transition on tick's <text> to make it 'wrappable'
-        tickText.nodes().forEach(node => interrupt(node));
-        const tickSize = axisGen.tickSize();
-        const axisPosition = this.getPosition();
-        const textMaxWidth = config.tickTextWidth || (config.type === AxisType.X ? this._containerWidth / (tickCount + 1) : this._containerWidth / 5);
-        tickText.each((value, i, elements) => {
-            var _a, _b;
-            let text = (_b = (_a = config.tickFormat) === null || _a === void 0 ? void 0 : _a.call(config, value, i, tickValues)) !== null && _b !== void 0 ? _b : `${value}`;
-            const textElement = elements[i];
-            // Get and cache the tick text style
-            if (!this._tickTextStyleCached) {
-                const styleDeclaration = getComputedStyle(textElement);
-                this._tickTextStyleCached = {
-                    fontSize: Number.parseFloat(styleDeclaration.fontSize),
-                    fontFamily: styleDeclaration.fontFamily,
-                    fontWidthToHeightRatio: getFontWidthToHeightRatio(),
-                };
-            }
-            // Calculate the text offset based on the axis position and the tick size
-            const [textOffsetX, textOffsetY] = this._getTickTextOffset(axisPosition, tickSize, this._tickTextStyleCached.fontSize);
-            // Prepare the Unovis text options
-            const textOptions = {
-                verticalAlign: config.type === AxisType.X ? VerticalAlign.Top : VerticalAlign.Middle,
-                width: textMaxWidth,
-                textRotationAngle: config.tickTextAngle,
-                separator: config.tickTextSeparator,
-                wordBreak: config.tickTextForceWordBreak,
-                x: textOffsetX,
-                y: textOffsetY,
-            };
-            if (config.tickTextFitMode === FitMode.Trim) {
-                const textElementSelection = select(textElement).text(text);
-                trimSVGText(textElementSelection, textMaxWidth, config.tickTextTrimType, true, this._tickTextStyleCached.fontSize, 0.58);
-                text = select(textElement).text();
-            }
-            const textBlock = Object.assign({ text }, this._tickTextStyleCached);
-            const dominantBaseline = config.type === AxisType.X ? 'central' : 'hanging';
-            renderTextToSvgTextElement(textElement, textBlock, textOptions, dominantBaseline);
-        });
-        selection
-            .classed(axis, true)
-            .classed(hideTickLine, !config.tickLine)
-            .classed(hideDomain, !config.domainLine);
-        if (config.fullSize) {
-            const path = this._getFullDomainPath(0);
-            smartTransition(selection.select('.domain'), duration).attr('d', path);
-        }
-    }
-    _resolveTickLabelOverlap(selection = this.axisGroup) {
-        const { config } = this;
-        const tickTextSelection = selection.selectAll(`g.tick > text:not(.${tickTextExiting})`);
-        if (!config.tickTextHideOverlapping) {
-            tickTextSelection.style('opacity', null);
-            return;
-        }
-        cancelAnimationFrame(this._collideTickLabelsAnimFrameId);
-        // Colliding labels in the next frame to prevent forced reflow
-        this._collideTickLabelsAnimFrameId = requestAnimationFrame(() => {
-            this._collideTickLabels(tickTextSelection);
-        });
-    }
-    _collideTickLabels(selection) {
-        // Reset visibility of all labels
-        selection.each((d, i, elements) => {
-            const node = elements[i];
-            node._visible = true;
-        });
-        // We do three iterations because not all overlapping labels can be resolved in the first iteration
-        const numIterations = 3;
-        for (let i = 0; i < numIterations; i += 1) {
-            // Run collision detection and set labels visibility
-            selection.each((d, i, elements) => {
-                const label1 = elements[i];
-                const isLabel1Visible = label1._visible;
-                if (!isLabel1Visible)
-                    return;
-                // Calculate bounding rect of point's label
-                const label1BoundingRect = label1.getBoundingClientRect();
-                for (let j = i + 1; j < elements.length; j += 1) {
-                    if (i === j)
-                        continue;
-                    const label2 = elements[j];
-                    const isLabel2Visible = label2._visible;
-                    if (isLabel2Visible) {
-                        const label2BoundingRect = label2.getBoundingClientRect();
-                        const intersect = rectIntersect(label1BoundingRect, label2BoundingRect, -5);
-                        if (intersect) {
-                            label2._visible = false;
-                            break;
-                        }
-                    }
-                }
-            });
-        }
-        // Hide the overlapping labels
-        selection.each((d, i, elements) => {
-            const label = elements[i];
-            select(label).style('opacity', label._visible ? 1 : 0);
-        });
-    }
-    _getNumTicks() {
-        const { config: { type, numTicks } } = this;
-        if (numTicks)
-            return numTicks;
-        if (type === AxisType.X) {
-            const xRange = this.xScale.range();
-            const width = xRange[1] - xRange[0];
-            return Math.floor(width / 175);
-        }
-        if (type === AxisType.Y) {
-            const yRange = this.yScale.range();
-            const height = Math.abs(yRange[0] - yRange[1]);
-            return Math.pow(height, 0.85) / 25;
-        }
-        return this._defaultNumTicks;
-    }
-    _getConfiguredTickValues() {
-        const { config } = this;
-        const scale = config.type === AxisType.X ? this.xScale : this.yScale;
-        const scaleDomain = scale === null || scale === void 0 ? void 0 : scale.domain();
-        if (config.tickValues) {
-            return config.tickValues.filter(v => (v >= scaleDomain[0]) && (v <= scaleDomain[1]));
-        }
-        return null;
-    }
-    _shouldRenderMinMaxTicksOnly() {
-        const { config } = this;
-        return config.minMaxTicksOnly || (config.type === AxisType.X && this._width < config.minMaxTicksOnlyWhenWidthIsLess);
-    }
-    _getFullDomainPath(tickSize = 0) {
-        const { config: { type } } = this;
-        switch (type) {
-            case AxisType.X: return `M0.5, ${tickSize} V0.5 H${this._width + 0.5} V${tickSize}`;
-            case AxisType.Y: return `M${-tickSize}, ${this._height + 0.5} H0.5 V0.5 H${-tickSize}`;
-        }
-    }
-    _renderAxisLabel(selection = this.axisGroup) {
-        var _a;
-        const { type, label: label$1, labelMargin, labelFontSize, labelTextFitMode } = this.config;
-        // Remove the old label first to calculate the axis size properly
-        selection.selectAll(`.${label}`).remove();
-        if (!label$1)
-            return;
-        // Calculate label position and rotation
-        const axisPosition = this.getPosition();
-        // We always use this.axisRenderHelperGroup to calculate the size of the axis because
-        //    this.axisGroup will give us incorrect values due to animation
-        const { width: axisWidth, height: axisHeight } = (_a = this._axisRawBBox) !== null && _a !== void 0 ? _a : selection.node().getBBox();
-        const rotation = type === AxisType.Y ? -90 : 0;
-        // Create the text element (without transform first)
-        const textElement = selection
-            .append('text')
-            .attr('class', label)
-            .attr('dy', `${this._getLabelDY()}em`)
-            .style('font-size', labelFontSize)
-            .style('fill', this.config.labelColor);
-        // Set the text content
-        textElement.text(label$1);
-        let isWrapped = false;
-        if (labelTextFitMode === FitMode.Wrap) {
-            // For Y-axis, use the chart height as the maximum width before rotation
-            const maxWidth = type === AxisType.Y ? this._height : this._width;
-            const currentTextWidth = textElement.node().getComputedTextLength();
-            if (currentTextWidth > maxWidth) {
-                wrapSVGText(textElement, maxWidth);
-                isWrapped = true;
-            }
-        }
-        // Calculate offset after wrapping to get accurate dimensions
-        let labelWidth = axisWidth;
-        let labelHeight = axisHeight;
-        if (labelTextFitMode === FitMode.Wrap) {
-            const labelBBox = textElement.node().getBBox();
-            labelWidth = labelBBox.width;
-            labelHeight = labelBBox.height;
-        }
-        else {
-            const trimWidth = type === AxisType.X ? labelWidth : labelHeight;
-            const styleDeclaration = getComputedStyle(textElement.node());
-            const fontSize = Number.parseFloat(styleDeclaration.fontSize);
-            // Use the default fontWidthToHeightRatio
-            trimSVGText(textElement, trimWidth, this.config.labelTextTrimType, true, fontSize);
-            const trimmedBBox = textElement.node().getBBox();
-            labelWidth = trimmedBBox.width;
-            labelHeight = trimmedBBox.height;
-        }
-        /*
-          we need to calculate the offset for the label based on the position and the fit mode
-          for offsetX, applying Y label we need to check if it's wrap or trim, then set the offset accordingly.
-          Same for offsetY, need to consider x label.
-        */
-        const offsetX = type === AxisType.X
-            ? this._width / 2
-            : type === AxisType.Y && labelTextFitMode === FitMode.Wrap && isWrapped
-                ? (axisPosition === Position.Left)
-                    ? -axisWidth - labelHeight / 2 - 10 // there's a 10px gap between tick label and Position.Right Y label, so offset as well in the Position.Left case
-                    : axisWidth
-                : Math.pow((-1), (+(axisPosition === Position.Left))) * axisWidth;
-        const offsetY = type === AxisType.Y
-            ? this._height / 2
-            : type === AxisType.X && labelTextFitMode === FitMode.Wrap
-                ? (axisPosition === Position.Top) ? -axisHeight - labelHeight / 2 : axisHeight
-                : Math.pow((-1), (+(axisPosition === Position.Top))) * axisHeight;
-        const marginX = type === AxisType.X ? 0 : Math.pow((-1), (+(axisPosition === Position.Left))) * labelMargin;
-        const marginY = type === AxisType.X ? Math.pow((-1), (+(axisPosition === Position.Top))) * labelMargin : 0;
-        // Apply transform and rotation after all calculations
-        textElement.attr('transform', `translate(${offsetX + marginX},${offsetY + marginY}) rotate(${rotation})`);
-    }
-    _getLabelDY() {
-        const { type, position } = this.config;
-        switch (type) {
-            case AxisType.X:
-                switch (position) {
-                    case Position.Top: return 0;
-                    case Position.Bottom:
-                    default: return 0.75;
-                }
-            case AxisType.Y:
-                switch (position) {
-                    case Position.Right: return 0.75;
-                    case Position.Left:
-                    default: return -0.25;
-                }
-        }
-    }
-    _getTickTextOffset(axisPosition, tickSize, fontSize) {
-        var _a;
-        const { config } = this;
-        const angleRad = ((_a = config.tickTextAngle) !== null && _a !== void 0 ? _a : 0) / 180 * Math.PI;
-        const baseOffset = tickSize + config.tickPadding;
-        if (config.type === AxisType.X) {
-            const direction = axisPosition === Position.Bottom ? 1 : -1;
-            return [
-                direction * baseOffset * Math.sin(angleRad),
-                direction * (baseOffset + fontSize / 2) * Math.cos(angleRad),
-            ];
-        }
-        else {
-            const direction = axisPosition === Position.Right ? 1 : -1;
-            return [
-                direction * baseOffset * Math.cos(angleRad),
-                direction * baseOffset * Math.sin(angleRad),
-            ];
-        }
-    }
-    _alignTickLabels(axisGroup = this.axisGroup) {
-        const { config: { type, tickTextAlign, tickTextAngle, position } } = this;
-        const activeTickTexts = axisGroup.selectAll(`g.tick > text:not(.${tickTextExiting})`);
-        const ticksData = activeTickTexts.data();
-        activeTickTexts.each((_, i, elements) => {
-            const tickTextElement = elements[i];
-            const tickDatum = ticksData[i];
-            // Compute the tick's target position from the scale rather than reading the DOM transform,
-            // which would return an interpolated value during a transition.
-            const tickPosition = type === AxisType.X
-                ? [this.xScale(tickDatum), 0]
-                : [0, this.yScale(tickDatum)];
-            const textAlign = (isFunction(tickTextAlign) ? tickTextAlign(tickDatum, i, ticksData, tickPosition, this._width, this._height) : tickTextAlign);
-            const textAnchor = textAlignToAnchor(textAlign);
-            const translateX = type === AxisType.X ? 0 : this._getYTickTextTranslate(textAlign, position);
-            const translateValue = tickTextAngle ? `translate(${translateX},0) rotate(${tickTextAngle})` : `translate(${translateX},0)`;
-            select(tickTextElement)
-                .attr('transform', translateValue)
-                .attr('text-anchor', textAnchor);
-        });
-    }
-    _getYTickTextTranslate(textAlign, axisPosition = Position.Left) {
-        var _a, _b, _c, _d;
-        /*
-          Default in D3 is 9, tickPadding is the spacing in pixels between the tick and it's label. Default: `8`
-        */
-        const defaultTickTextSpacingPx = this.config.tickPadding + 1;
-        // this._axisRawBBox will be undefined when autoMargin is undefined
-        const width = ((_d = (_b = (_a = this._axisRawBBox) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : (_c = this.axisGroup.node()) === null || _c === void 0 ? void 0 : _c.getBBox().width) !== null && _d !== void 0 ? _d : 0) - defaultTickTextSpacingPx;
-        switch (textAlign) {
-            case TextAlign.Left: return axisPosition === Position.Left ? width * -1 : 0;
-            case TextAlign.Right: return axisPosition === Position.Left ? 0 : width;
-            case TextAlign.Center: return axisPosition === Position.Left ? width * (-0.5) : width * 0.5;
-            default: return 0;
-        }
-    }
-}
-Axis.selectors = style;
-
-export { Axis };
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@unovis/ts/components/axis/style.js

@@ -1,121 +0,0 @@
-import { css } from '@emotion/css';
-import { getCssVarNames, injectGlobalCssVariables } from '../../utils/style.js';
-
-const root = css `
-  label: axis-component;
-`;
-const cssVarDefaults = {
-    '--vis-axis-font-family': undefined,
-    '--vis-axis-tick-color': '#e8e9ef',
-    '--vis-axis-domain-color': undefined,
-    '--vis-axis-domain-line-dasharray': undefined,
-    '--vis-axis-grid-color': '#e8e9ef',
-    '--vis-axis-grid-line-width': '1px',
-    '--vis-axis-grid-line-dasharray': 'none',
-    '--vis-axis-grid-opacity': '1',
-    '--vis-axis-grid-transition': 'none',
-    '--vis-axis-label-font-size': '14px',
-    '--vis-axis-label-color': '#6c778c',
-    '--vis-axis-label-weight': '500',
-    '--vis-axis-tick-label-color': '#6c778c',
-    '--vis-axis-tick-label-font-size': '12px',
-    '--vis-axis-tick-label-weight': '500',
-    '--vis-axis-tick-label-cursor': 'default',
-    '--vis-axis-tick-label-text-decoration': 'none',
-    '--vis-axis-tick-line-width': '1px',
-    '--vis-axis-tick-label-hide-transition': 'opacity 400ms ease-in-out',
-    '--vis-axis-domain-line-width': undefined,
-    '--vis-dark-axis-tick-color': '#6c778c',
-    '--vis-dark-axis-domain-color': undefined,
-    '--vis-dark-axis-tick-label-color': '#e8e9ef',
-    '--vis-dark-axis-grid-color': '#6c778c',
-    '--vis-dark-axis-label-color': '#fefefe',
-};
-const variables = getCssVarNames(cssVarDefaults);
-injectGlobalCssVariables(cssVarDefaults, root);
-const hideTickLine = css `
-  label: hide-tick-line;
-`;
-const hideDomain = css `
-  label: hide-domain;
-`;
-const axis = css `
-  label: axis;
-
-  user-select: none;
-
-  .domain {
-    stroke: var(${variables.axisDomainColor}, var(${variables.axisTickColor}));
-    stroke-width: var(${variables.axisDomainLineWidth}, var(${variables.axisGridLineWidth}));
-    stroke-dasharray: var(${variables.axisDomainLineDasharray}, var(${variables.axisGridLineDasharray}));
-  }
-
-  &${`.${hideTickLine}`} {
-    .tick > line {
-      opacity: 0;
-    }
-  }
-
-  &${`.${hideDomain}`} {
-    .domain {
-      opacity: 0;
-    }
-  }
-`;
-const grid = css `
-  label: grid;
-
-  .domain {
-    opacity: 0;
-  }
-
-  line {
-    stroke: var(${variables.axisGridColor});
-    stroke-width: var(${variables.axisGridLineWidth});
-    stroke-dasharray: var(${variables.axisGridLineDasharray});
-    opacity: var(${variables.axisGridOpacity});
-    transition: var(${variables.axisGridTransition});
-  }
-`;
-const tick = css `
-  label: tick;
-
-  stroke: none;
-  font-size: var(${variables.axisTickLabelFontSize});
-  font-weight: var(${variables.axisTickLabelWeight});
-
-  line {
-    stroke: var(${variables.axisTickColor});
-    stroke-width: var(${variables.axisTickLineWidth});
-  }
-
-  text {
-    fill: var(${variables.axisTickLabelColor});
-    cursor: var(${variables.axisTickLabelCursor});
-    font-family: var(${variables.axisFontFamily}, var(--vis-font-family));
-    text-decoration: var(${variables.axisTickLabelTextDecoration});
-    stroke: none;
-  }
-`;
-const tickTextExiting = css `
-  label: tick-text-exiting;
-`;
-const label = css `
-  label: label;
-  fill: var(${variables.axisLabelColor});
-  font-size: var(${variables.axisLabelFontSize});
-  font-weight: var(${variables.axisLabelWeight});
-  font-family: var(${variables.axisFontFamily}, var(--vis-font-family));
-  text-anchor: middle;
-`;
-const tickLabel = css `
-  label: tick-label;
-`;
-const tickLabelHideable = css `
-  label: tick-label-hideable;
-  opacity: 0;
-  transition: var(${variables.axisTickLabelHideTransition});
-`;
-
-export { axis, cssVarDefaults, grid, hideDomain, hideTickLine, label, root, tick, tickLabel, tickLabelHideable, tickTextExiting, variables };
-//# sourceMappingURL=style.js.map

package/.output/server/node_modules/@unovis/ts/components/axis/types.js

@@ -1,8 +0,0 @@
-var AxisType;
-(function (AxisType) {
-    AxisType["X"] = "x";
-    AxisType["Y"] = "y";
-})(AxisType || (AxisType = {}));
-
-export { AxisType };
-//# sourceMappingURL=types.js.map

package/.output/server/node_modules/@unovis/ts/components/brush/config.js

@@ -1,15 +0,0 @@
-import { XYComponentDefaultConfig } from '../../core/xy-component/config.js';
-import { Arrangement } from '../../types/position.js';
-
-const BrushDefaultConfig = Object.assign(Object.assign({}, XYComponentDefaultConfig), { 
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function */
-    onBrush: (s, e, userDriven) => { }, 
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function */
-    onBrushStart: (s, e, userDriven) => { }, 
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function */
-    onBrushMove: (s, e, userDriven) => { }, 
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function */
-    onBrushEnd: (s, e, userDriven) => { }, handleWidth: 9, selection: null, draggable: false, handlePosition: Arrangement.Inside, selectionMinLength: undefined, brushHeightExtend: 0 });
-
-export { BrushDefaultConfig };
-//# sourceMappingURL=config.js.map