@fluentui/web-components 2.5.12 → 3.0.0-alpha.10

package/dist/esm/color/palette.js

@@ -1,250 +0,0 @@
-import { clamp, ColorHSL, ColorLAB, ColorRGBA64, hslToRGB, interpolateRGB, labToRGB, rgbToHSL, rgbToLAB, roundToPrecisionSmall, } from '@microsoft/fast-colors';
-import { isSwatchRGB, SwatchRGB } from './swatch';
-import { binarySearch } from './utilities/binary-search';
-import { directionByIsDark } from './utilities/direction-by-is-dark';
-import { contrast } from './utilities/relative-luminance';
-const defaultPaletteRGBOptions = {
-    stepContrast: 1.03,
-    stepContrastRamp: 0.03,
-    preserveSource: false,
-};
-function create(rOrSource, g, b) {
-    if (typeof rOrSource === 'number') {
-        return PaletteRGB.from(SwatchRGB.create(rOrSource, g, b));
-    }
-    else {
-        return PaletteRGB.from(rOrSource);
-    }
-}
-function from(source, options) {
-    return isSwatchRGB(source)
-        ? PaletteRGBImpl.from(source, options)
-        : PaletteRGBImpl.from(SwatchRGB.create(source.r, source.g, source.b), options);
-}
-/** @public */
-export const PaletteRGB = Object.freeze({
-    create,
-    from,
-});
-/**
- * A {@link Palette} representing RGB swatch values.
- * @public
- */
-class PaletteRGBImpl {
-    /**
-     *
-     * @param source - The source color for the palette
-     * @param swatches - All swatches in the palette
-     */
-    constructor(source, swatches) {
-        this.closestIndexCache = new Map();
-        this.source = source;
-        this.swatches = swatches;
-        this.reversedSwatches = Object.freeze([...this.swatches].reverse());
-        this.lastIndex = this.swatches.length - 1;
-    }
-    /**
-     * {@inheritdoc Palette.colorContrast}
-     */
-    colorContrast(reference, contrastTarget, initialSearchIndex, direction) {
-        if (initialSearchIndex === undefined) {
-            initialSearchIndex = this.closestIndexOf(reference);
-        }
-        let source = this.swatches;
-        const endSearchIndex = this.lastIndex;
-        let startSearchIndex = initialSearchIndex;
-        if (direction === undefined) {
-            direction = directionByIsDark(reference);
-        }
-        const condition = (value) => contrast(reference, value) >= contrastTarget;
-        if (direction === -1) {
-            source = this.reversedSwatches;
-            startSearchIndex = endSearchIndex - startSearchIndex;
-        }
-        return binarySearch(source, condition, startSearchIndex, endSearchIndex);
-    }
-    /**
-     * {@inheritdoc Palette.get}
-     */
-    get(index) {
-        return this.swatches[index] || this.swatches[clamp(index, 0, this.lastIndex)];
-    }
-    /**
-     * {@inheritdoc Palette.closestIndexOf}
-     */
-    closestIndexOf(reference) {
-        if (this.closestIndexCache.has(reference.relativeLuminance)) {
-            return this.closestIndexCache.get(reference.relativeLuminance);
-        }
-        let index = this.swatches.indexOf(reference);
-        if (index !== -1) {
-            this.closestIndexCache.set(reference.relativeLuminance, index);
-            return index;
-        }
-        const closest = this.swatches.reduce((previous, next) => Math.abs(next.relativeLuminance - reference.relativeLuminance) <
-            Math.abs(previous.relativeLuminance - reference.relativeLuminance)
-            ? next
-            : previous);
-        index = this.swatches.indexOf(closest);
-        this.closestIndexCache.set(reference.relativeLuminance, index);
-        return index;
-    }
-    /**
-     * Bump the saturation if it falls below the reference color saturation.
-     * @param reference Color with target saturation
-     * @param color Color to check and bump if below target saturation
-     * @returns Original or adjusted color
-     */
-    static saturationBump(reference, color) {
-        const hslReference = rgbToHSL(reference);
-        const saturationTarget = hslReference.s;
-        const hslColor = rgbToHSL(color);
-        if (hslColor.s < saturationTarget) {
-            const hslNew = new ColorHSL(hslColor.h, saturationTarget, hslColor.l);
-            return hslToRGB(hslNew);
-        }
-        return color;
-    }
-    /**
-     * Scales input from 0 to 100 to 0 to 0.5.
-     * @param l Input number, 0 to 100
-     * @returns Output number, 0 to 0.5
-     */
-    static ramp(l) {
-        const inputval = l / 100;
-        if (inputval > 0.5)
-            return (inputval - 0.5) / 0.5; //from 0.500001in = 0.00000001out to 1.0in = 1.0out
-        return 2 * inputval; //from 0in = 0out to 0.5in = 1.0out
-    }
-    /**
-     * Create a palette following the desired curve and many steps to build a smaller palette from.
-     * @param source The source swatch to create a palette from
-     * @returns The palette
-     */
-    static createHighResolutionPalette(source) {
-        const swatches = [];
-        const labSource = rgbToLAB(ColorRGBA64.fromObject(source).roundToPrecision(4));
-        const lab0 = labToRGB(new ColorLAB(0, labSource.a, labSource.b)).clamp().roundToPrecision(4);
-        const lab50 = labToRGB(new ColorLAB(50, labSource.a, labSource.b)).clamp().roundToPrecision(4);
-        const lab100 = labToRGB(new ColorLAB(100, labSource.a, labSource.b)).clamp().roundToPrecision(4);
-        const rgbMin = new ColorRGBA64(0, 0, 0);
-        const rgbMax = new ColorRGBA64(1, 1, 1);
-        const lAbove = lab100.equalValue(rgbMax) ? 0 : 14;
-        const lBelow = lab0.equalValue(rgbMin) ? 0 : 14;
-        // 257 levels max, depending on whether lab0 or lab100 are black or white respectively.
-        for (let l = 100 + lAbove; l >= 0 - lBelow; l -= 0.5) {
-            let rgb;
-            if (l < 0) {
-                // For L less than 0, scale from black to L=0
-                const percentFromRgbMinToLab0 = l / lBelow + 1;
-                rgb = interpolateRGB(percentFromRgbMinToLab0, rgbMin, lab0);
-            }
-            else if (l <= 50) {
-                // For L less than 50, we scale from L=0 to the base color
-                rgb = interpolateRGB(PaletteRGBImpl.ramp(l), lab0, lab50);
-            }
-            else if (l <= 100) {
-                // For L less than 100, scale from the base color to L=100
-                rgb = interpolateRGB(PaletteRGBImpl.ramp(l), lab50, lab100);
-            }
-            else {
-                // For L greater than 100, scale from L=100 to white
-                const percentFromLab100ToRgbMax = (l - 100.0) / lAbove;
-                rgb = interpolateRGB(percentFromLab100ToRgbMax, lab100, rgbMax);
-            }
-            rgb = PaletteRGBImpl.saturationBump(lab50, rgb).roundToPrecision(4);
-            swatches.push(SwatchRGB.from(rgb));
-        }
-        return new PaletteRGBImpl(source, swatches);
-    }
-    /**
-     * Adjust one end of the contrast-based palette so it doesn't abruptly fall to black (or white).
-     * @param swatchContrast Function to get the target contrast for the next swatch
-     * @param referencePalette The high resolution palette
-     * @param targetPalette The contrast-based palette to adjust
-     * @param direction The end to adjust
-     */
-    static adjustEnd(swatchContrast, referencePalette, targetPalette, direction) {
-        // Careful with the use of referencePalette as only the refSwatches is reversed.
-        const refSwatches = direction === -1 ? referencePalette.swatches : referencePalette.reversedSwatches;
-        const refIndex = (swatch) => {
-            const index = referencePalette.closestIndexOf(swatch);
-            return direction === 1 ? referencePalette.lastIndex - index : index;
-        };
-        // Only operates on the 'end' end of the array, so flip if we're adjusting the 'beginning'
-        if (direction === 1) {
-            targetPalette.reverse();
-        }
-        const targetContrast = swatchContrast(targetPalette[targetPalette.length - 2]);
-        const actualContrast = roundToPrecisionSmall(contrast(targetPalette[targetPalette.length - 1], targetPalette[targetPalette.length - 2]), 2);
-        if (actualContrast < targetContrast) {
-            // Remove last swatch if not sufficient contrast
-            targetPalette.pop();
-            // Distribute to the last swatch
-            const safeSecondSwatch = referencePalette.colorContrast(refSwatches[referencePalette.lastIndex], targetContrast, undefined, direction);
-            const safeSecondRefIndex = refIndex(safeSecondSwatch);
-            const targetSwatchCurrentRefIndex = refIndex(targetPalette[targetPalette.length - 2]);
-            const swatchesToSpace = safeSecondRefIndex - targetSwatchCurrentRefIndex;
-            let space = 1;
-            for (let i = targetPalette.length - swatchesToSpace - 1; i < targetPalette.length; i++) {
-                const currentRefIndex = refIndex(targetPalette[i]);
-                const nextRefIndex = i === targetPalette.length - 1 ? referencePalette.lastIndex : currentRefIndex + space;
-                targetPalette[i] = refSwatches[nextRefIndex];
-                space++;
-            }
-        }
-        if (direction === 1) {
-            targetPalette.reverse();
-        }
-    }
-    /**
-     * Generate a palette with consistent minimum contrast between swatches.
-     * @param source The source color
-     * @param options Palette generation options
-     * @returns A palette meeting the requested contrast between swatches.
-     */
-    static createColorPaletteByContrast(source, options) {
-        const referencePalette = PaletteRGBImpl.createHighResolutionPalette(source);
-        // Ramp function to increase contrast as the swatches get darker
-        const nextContrast = (swatch) => {
-            const c = options.stepContrast + options.stepContrast * (1 - swatch.relativeLuminance) * options.stepContrastRamp;
-            return roundToPrecisionSmall(c, 2);
-        };
-        const swatches = [];
-        // Start with the source color or the light end color
-        let ref = options.preserveSource ? source : referencePalette.swatches[0];
-        swatches.push(ref);
-        // Add swatches with contrast toward dark
-        do {
-            const targetContrast = nextContrast(ref);
-            ref = referencePalette.colorContrast(ref, targetContrast, undefined, 1);
-            swatches.push(ref);
-        } while (ref.relativeLuminance > 0);
-        // Add swatches with contrast toward light
-        if (options.preserveSource) {
-            ref = source;
-            do {
-                // This is off from the dark direction because `ref` here is the darker swatch, probably subtle
-                const targetContrast = nextContrast(ref);
-                ref = referencePalette.colorContrast(ref, targetContrast, undefined, -1);
-                swatches.unshift(ref);
-            } while (ref.relativeLuminance < 1);
-        }
-        // Validate dark end
-        this.adjustEnd(nextContrast, referencePalette, swatches, -1);
-        // Validate light end
-        if (options.preserveSource) {
-            this.adjustEnd(nextContrast, referencePalette, swatches, 1);
-        }
-        return swatches;
-    }
-    /**
-     * Create a color palette from a provided swatch
-     * @param source - The source swatch to create a palette from
-     * @returns
-     */
-    static from(source, options) {
-        const opts = options === void 0 || null ? defaultPaletteRGBOptions : Object.assign(Object.assign({}, defaultPaletteRGBOptions), options);
-        return new PaletteRGBImpl(source, Object.freeze(PaletteRGBImpl.createColorPaletteByContrast(source, opts)));
-    }
-}

package/dist/esm/color/recipes/contrast-and-delta-swatch-set.js

@@ -1,28 +0,0 @@
-import { directionByIsDark } from '../utilities/direction-by-is-dark';
-import { isDark } from '../utilities/is-dark';
-/**
- * @internal
- */
-export function contrastAndDeltaSwatchSet(palette, reference, baseContrast, restDelta, hoverDelta, activeDelta, focusDelta, direction) {
-    if (direction === null || direction === void 0) {
-        direction = directionByIsDark(reference);
-    }
-    const baseIndex = palette.closestIndexOf(palette.colorContrast(reference, baseContrast));
-    return {
-        rest: palette.get(baseIndex + direction * restDelta),
-        hover: palette.get(baseIndex + direction * hoverDelta),
-        active: palette.get(baseIndex + direction * activeDelta),
-        focus: palette.get(baseIndex + direction * focusDelta),
-    };
-}
-/**
- * @internal
- */
-export function contrastAndDeltaSwatchSetByLuminance(palette, reference, lightBaseContrast, lightRestDelta, lightHoverDelta, lightActiveDelta, lightFocusDelta, lightDirection = undefined, darkBaseContrast, darkRestDelta, darkHoverDelta, darkActiveDelta, darkFocusDelta, darkDirection = undefined) {
-    if (isDark(reference)) {
-        return contrastAndDeltaSwatchSet(palette, reference, darkBaseContrast, darkRestDelta, darkHoverDelta, darkActiveDelta, darkFocusDelta, darkDirection);
-    }
-    else {
-        return contrastAndDeltaSwatchSet(palette, reference, lightBaseContrast, lightRestDelta, lightHoverDelta, lightActiveDelta, lightFocusDelta, lightDirection);
-    }
-}

package/dist/esm/color/recipes/contrast-swatch.js

@@ -1,12 +0,0 @@
-/**
- * Color algorithm using contrast from the reference color.
- *
- * @param palette - The palette to operate on
- * @param reference - The reference color
- * @param contrast - The desired minimum contrast
- *
- * @internal
- */
-export function contrastSwatch(palette, reference, contrast) {
-    return palette.colorContrast(reference, contrast);
-}

package/dist/esm/color/recipes/delta-swatch-set.js

@@ -1,53 +0,0 @@
-import { directionByIsDark } from '../utilities/direction-by-is-dark';
-import { isDark } from '../utilities/is-dark';
-/**
- * Color algorithm using deltas from the reference color for states.
- *
- * @param palette The palette to operate on
- * @param reference The reference color to calculate a color for
- * @param restDelta The rest state offset from reference
- * @param hoverDelta The hover state offset from reference
- * @param activeDelta The active state offset from reference
- * @param focusDelta The focus state offset from reference
- * @param direction The direction the deltas move on the ramp, default goes darker for light references and lighter for dark references
- *
- * @internal
- */
-export function deltaSwatchSet(palette, reference, restDelta, hoverDelta, activeDelta, focusDelta, direction) {
-    const referenceIndex = palette.closestIndexOf(reference);
-    if (direction === null || direction === void 0) {
-        direction = directionByIsDark(reference);
-    }
-    return {
-        rest: palette.get(referenceIndex + direction * restDelta),
-        hover: palette.get(referenceIndex + direction * hoverDelta),
-        active: palette.get(referenceIndex + direction * activeDelta),
-        focus: palette.get(referenceIndex + direction * focusDelta),
-    };
-}
-/**
- * Color algorithm using deltas from the reference color for states, allowing different deltas based on a light or dark reference color.
- *
- * @param palette The palette to operate on
- * @param reference The reference color to calculate a color for
- * @param lightRestDelta The rest offset for a light reference
- * @param lightHoverDelta The hover offset for a light reference
- * @param lightActiveDelta The rest offset for a light reference
- * @param lightFocusDelta The hover offset for a light reference
- * @param lightDirection The direction the deltas move on the ramp, default goes darker for light references
- * @param darkRestDelta The rest offset for a dark reference
- * @param darkHoverDelta The hover offset for a dark reference
- * @param darkActiveDelta The rest offset for a dark reference
- * @param darkFocusDelta The hover offset for a dark reference
- * @param darkDirection The direction the deltas move on the ramp, default goes lighter for dark references
- *
- * @internal
- */
-export function deltaSwatchSetByLuminance(palette, reference, lightRestDelta, lightHoverDelta, lightActiveDelta, lightFocusDelta, lightDirection = undefined, darkRestDelta, darkHoverDelta, darkActiveDelta, darkFocusDelta, darkDirection = undefined) {
-    if (isDark(reference)) {
-        return deltaSwatchSet(palette, reference, darkRestDelta, darkHoverDelta, darkActiveDelta, darkFocusDelta, darkDirection);
-    }
-    else {
-        return deltaSwatchSet(palette, reference, lightRestDelta, lightHoverDelta, lightActiveDelta, lightFocusDelta, lightDirection);
-    }
-}

package/dist/esm/color/recipes/delta-swatch.js

@@ -1,13 +0,0 @@
-import { directionByIsDark } from '../utilities/direction-by-is-dark';
-/**
- * Color algorithm using a delta from the reference color.
- *
- * @param palette - The palette to operate on
- * @param reference - The reference color
- * @param delta - The offset from the reference
- *
- * @internal
- */
-export function deltaSwatch(palette, reference, delta) {
-    return palette.get(palette.closestIndexOf(reference) + directionByIsDark(reference) * delta);
-}

package/dist/esm/color/recipes/focus-stroke.js

@@ -1,14 +0,0 @@
-import { black, white } from '../utilities/color-constants';
-import { isDark } from '../utilities/is-dark';
-/**
- * @internal
- */
-export function focusStrokeOuter(palette, reference) {
-    return isDark(reference) ? white : black;
-}
-/**
- * @internal
- */
-export function focusStrokeInner(palette, reference, focusColor) {
-    return isDark(reference) ? black : white;
-}

package/dist/esm/color/recipes/foreground-on-accent.js

@@ -1,21 +0,0 @@
-import { black, white } from '../utilities/color-constants';
-/**
- * @internal
- */
-export function foregroundOnAccent(reference, contrastTarget) {
-    return reference.contrast(white) >= contrastTarget ? white : black;
-}
-export function foregroundOnAccentSet(restFill, hoverFill, activeFill, focusFill, contrastTarget) {
-    const defaultRule = fill => (fill.contrast(white) >= contrastTarget ? white : black);
-    const restForeground = defaultRule(restFill);
-    const hoverForeground = defaultRule(hoverFill);
-    // Active doe not have contrast requirements, so if rest and hover use the same color, use that for active even if it would not have passed the contrast check.
-    const activeForeground = restForeground.relativeLuminance === hoverForeground.relativeLuminance ? restForeground : defaultRule(activeFill);
-    const focusForeground = defaultRule(focusFill);
-    return {
-        rest: restForeground,
-        hover: hoverForeground,
-        active: activeForeground,
-        focus: focusForeground,
-    };
-}

package/dist/esm/color/recipes/gradient-shadow-stroke.js

@@ -1,54 +0,0 @@
-import { calculateOverlayColor, ColorRGBA64, computeAlphaBlend, parseColorHexRGB } from '@microsoft/fast-colors';
-import { SwatchRGB } from '../swatch';
-import { directionByIsDark } from '../utilities/direction-by-is-dark';
-import { GradientSwatchRGB } from './gradient-swatch';
-const black = new ColorRGBA64(0, 0, 0);
-const white = new ColorRGBA64(1, 1, 1);
-/**
- * @internal
- */
-export function gradientShadowStroke(palette, reference, restDelta, hoverDelta, activeDelta, focusDelta, shadowDelta, direction, shadowPercentage = 10, blendWithReference = false) {
-    const referenceIndex = palette.closestIndexOf(reference);
-    if (direction === void 0) {
-        direction = directionByIsDark(reference);
-    }
-    function overlayHelper(color) {
-        if (blendWithReference) {
-            const refIndex = palette.closestIndexOf(reference);
-            const refSwatch = palette.get(refIndex);
-            const overlaySolid = color.relativeLuminance < reference.relativeLuminance ? black : white;
-            const overlayColor = calculateOverlayColor(parseColorHexRGB(color.toColorString()), parseColorHexRGB(refSwatch.toColorString()), overlaySolid).roundToPrecision(2);
-            const blend = computeAlphaBlend(parseColorHexRGB(reference.toColorString()), overlayColor);
-            return SwatchRGB.from(blend);
-        }
-        else {
-            return color;
-        }
-    }
-    const restIndex = referenceIndex + direction * restDelta;
-    const hoverIndex = restIndex + direction * (hoverDelta - restDelta);
-    const activeIndex = restIndex + direction * (activeDelta - restDelta);
-    const focusIndex = restIndex + direction * (focusDelta - restDelta);
-    const startPosition = direction === -1 ? 0 : 100 - shadowPercentage;
-    const endPosition = direction === -1 ? shadowPercentage : 100;
-    function gradientHelper(index, applyShadow) {
-        const color = palette.get(index);
-        if (applyShadow) {
-            // Shadow is actually "highlight" on top in dark mode.
-            const shadowColor = palette.get(index + direction * shadowDelta);
-            const startColor = direction === -1 ? shadowColor : color;
-            const endColor = direction === -1 ? color : shadowColor;
-            const g = `linear-gradient(${overlayHelper(startColor).toColorString()} ${startPosition}%, ${overlayHelper(endColor).toColorString()} ${endPosition}%)`;
-            return GradientSwatchRGB.fromObject(startColor, g);
-        }
-        else {
-            return overlayHelper(color);
-        }
-    }
-    return {
-        rest: gradientHelper(restIndex, true),
-        hover: gradientHelper(hoverIndex, true),
-        active: gradientHelper(activeIndex, false),
-        focus: gradientHelper(focusIndex, true),
-    };
-}

package/dist/esm/color/recipes/gradient-swatch.js

@@ -1,36 +0,0 @@
-import { ColorRGBA64, rgbToRelativeLuminance } from '@microsoft/fast-colors';
-import { contrast } from '../utilities/relative-luminance';
-/**
- * An implementation of {@link Swatch} that produces a gradient.
- * This assumes a subtle gradient such that `relativeLuminance` is still meaningful,
- * either with consistent luminance across the steps or a small edge of larger change.
- * @internal
- */
-export class GradientSwatchRGB {
-    /**
-     *
-     * @param red Red channel expressed as a number between 0 and 1
-     * @param green Green channel expressed as a number between 0 and 1
-     * @param blue Blue channel expressed as a number between 0 and 1
-     */
-    constructor(red, green, blue, cssGradient) {
-        this.toColorString = () => this.cssGradient;
-        this.contrast = contrast.bind(null, this);
-        this.createCSS = this.toColorString;
-        this.color = new ColorRGBA64(red, green, blue);
-        this.cssGradient = cssGradient;
-        this.relativeLuminance = rgbToRelativeLuminance(this.color);
-        this.r = red;
-        this.g = green;
-        this.b = blue;
-    }
-    /**
-     * Creates a GradientSwatch from a base color and gradient definition
-     * @param obj The base color object, used for relative luminance
-     * @param cssGradient The actual gradient to be rendered
-     * @returns New GradientSwatch object
-     */
-    static fromObject(obj, cssGradient) {
-        return new GradientSwatchRGB(obj.r, obj.g, obj.b, cssGradient);
-    }
-}

package/dist/esm/color/recipes/neutral-layer-1.js

@@ -1,13 +0,0 @@
-import { baseLayerLuminanceSwatch } from '../utilities/base-layer-luminance';
-/**
- * @internal
- */
-export function neutralLayer1Index(palette, baseLayerLuminance) {
-    return palette.closestIndexOf(baseLayerLuminanceSwatch(baseLayerLuminance));
-}
-/**
- * @internal
- */
-export function neutralLayer1(palette, baseLayerLuminance) {
-    return palette.get(neutralLayer1Index(palette, baseLayerLuminance));
-}

package/dist/esm/color/recipes/neutral-layer-2.js

@@ -1,7 +0,0 @@
-import { neutralLayer1Index } from './neutral-layer-1';
-/**
- * @internal
- */
-export function neutralLayer2(palette, baseLayerLuminance, layerDelta) {
-    return palette.get(neutralLayer1Index(palette, baseLayerLuminance) + layerDelta * -1);
-}

package/dist/esm/color/recipes/neutral-layer-3.js

@@ -1,7 +0,0 @@
-import { neutralLayer1Index } from './neutral-layer-1';
-/**
- * @internal
- */
-export function neutralLayer3(palette, baseLayerLuminance, layerDelta) {
-    return palette.get(neutralLayer1Index(palette, baseLayerLuminance) + layerDelta * -1 * 2);
-}

package/dist/esm/color/recipes/neutral-layer-4.js

@@ -1,7 +0,0 @@
-import { neutralLayer1Index } from './neutral-layer-1';
-/**
- * @internal
- */
-export function neutralLayer4(palette, baseLayerLuminance, layerDelta) {
-    return palette.get(neutralLayer1Index(palette, baseLayerLuminance) + layerDelta * -1 * 3);
-}

package/dist/esm/color/recipes/neutral-layer-floating.js

@@ -1,7 +0,0 @@
-import { neutralLayer1Index } from './neutral-layer-1';
-/**
- * @internal
- */
-export function neutralLayerFloating(palette, baseLayerLuminance, layerDelta) {
-    return palette.get(neutralLayer1Index(palette, baseLayerLuminance) + layerDelta);
-}

package/dist/esm/color/recipes/underline-stroke.js

@@ -1,31 +0,0 @@
-import { directionByIsDark } from '../utilities/direction-by-is-dark';
-import { GradientSwatchRGB } from './gradient-swatch';
-/**
- * @internal
- */
-export function underlineStroke(palette, reference, restDelta, hoverDelta, activeDelta, focusDelta, shadowDelta, width) {
-    const referenceIndex = palette.closestIndexOf(reference);
-    const direction = directionByIsDark(reference);
-    const restIndex = referenceIndex + direction * restDelta;
-    const hoverIndex = restIndex + direction * (hoverDelta - restDelta);
-    const activeIndex = restIndex + direction * (activeDelta - restDelta);
-    const focusIndex = restIndex + direction * (focusDelta - restDelta);
-    const midPosition = `calc(100% - ${width})`;
-    function gradientHelper(index, applyShadow) {
-        const color = palette.get(index);
-        if (applyShadow) {
-            const underlineColor = palette.get(index + direction * shadowDelta);
-            const g = `linear-gradient(${color.toColorString()} ${midPosition}, ${underlineColor.toColorString()} ${midPosition}, ${underlineColor.toColorString()})`;
-            return GradientSwatchRGB.fromObject(color, g);
-        }
-        else {
-            return color;
-        }
-    }
-    return {
-        rest: gradientHelper(restIndex, true),
-        hover: gradientHelper(hoverIndex, true),
-        active: gradientHelper(activeIndex, false),
-        focus: gradientHelper(focusIndex, true),
-    };
-}

package/dist/esm/color/swatch.js

@@ -1,53 +0,0 @@
-import { ColorRGBA64, rgbToRelativeLuminance } from '@microsoft/fast-colors';
-import { contrast } from './utilities/relative-luminance';
-/** @public */
-export const SwatchRGB = Object.freeze({
-    create(r, g, b) {
-        return new SwatchRGBImpl(r, g, b);
-    },
-    from(obj) {
-        return new SwatchRGBImpl(obj.r, obj.g, obj.b);
-    },
-});
-/**
- * Runtime test for an objects conformance with the SwatchRGB interface.
- * @internal
- */
-export function isSwatchRGB(value) {
-    const test = {
-        r: 0,
-        g: 0,
-        b: 0,
-        toColorString: () => '',
-        contrast: () => 0,
-        relativeLuminance: 0,
-    };
-    for (const key in test) {
-        if (typeof test[key] !== typeof value[key]) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * An RGB implementation of {@link Swatch}
- * @internal
- */
-class SwatchRGBImpl extends ColorRGBA64 {
-    /**
-     *
-     * @param red - Red channel expressed as a number between 0 and 1
-     * @param green - Green channel expressed as a number between 0 and 1
-     * @param blue - Blue channel expressed as a number between 0 and 1
-     */
-    constructor(red, green, blue) {
-        super(red, green, blue, 1);
-        this.toColorString = this.toStringHexRGB;
-        this.contrast = contrast.bind(null, this);
-        this.createCSS = this.toColorString;
-        this.relativeLuminance = rgbToRelativeLuminance(this);
-    }
-    static fromObject(obj) {
-        return new SwatchRGBImpl(obj.r, obj.g, obj.b);
-    }
-}

package/dist/esm/color/utilities/base-layer-luminance.js

@@ -1,14 +0,0 @@
-import { SwatchRGB } from '../swatch';
-export function baseLayerLuminanceSwatch(luminance) {
-    return SwatchRGB.create(luminance, luminance, luminance);
-}
-/**
- * Recommended values for light and dark mode for {@link @fluentui/web-components#baseLayerLuminance}.
- *
- * @public
- */
-export var StandardLuminance;
-(function (StandardLuminance) {
-    StandardLuminance[StandardLuminance["LightMode"] = 0.98] = "LightMode";
-    StandardLuminance[StandardLuminance["DarkMode"] = 0.15] = "DarkMode";
-})(StandardLuminance || (StandardLuminance = {}));

package/dist/esm/color/utilities/binary-search.js

@@ -1,15 +0,0 @@
-/**
- * @internal
- */
-export function binarySearch(valuesToSearch, searchCondition, startIndex = 0, endIndex = valuesToSearch.length - 1) {
-    if (endIndex === startIndex) {
-        return valuesToSearch[startIndex];
-    }
-    const middleIndex = Math.floor((endIndex - startIndex) / 2) + startIndex;
-    // Check to see if this passes on the item in the center of the array
-    // if it does check the previous values
-    return searchCondition(valuesToSearch[middleIndex])
-        ? binarySearch(valuesToSearch, searchCondition, startIndex, middleIndex)
-        : binarySearch(valuesToSearch, searchCondition, middleIndex + 1, // exclude this index because it failed the search condition
-        endIndex);
-}