@esri/solutions-components 0.8.2 → 0.8.3

package/dist/solutions-components/calcite-color-picker.entry.js

@@ -0,0 +1,906 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { r as registerInstance, e as createEvent, h, g as getElement } from './index-bdfaac50.js';
+import { c as color } from './index-b1fb529b.js';
+import { t as throttle } from './lodash-98e4b7d0.js';
+import { i as isPrimaryPointerButton, a as getElementDir } from './dom-b91aa537.js';
+import { O as OPACITY_LIMITS, R as RGB_LIMITS, H as HSV_LIMITS, C as CSS, D as DEFAULT_STORAGE_KEY_PREFIX, a as DEFAULT_COLOR, b as DIMENSIONS, c as HUE_LIMIT_CONSTRAINED, S as SCOPE_SIZE } from './resources-47b3ca40.js';
+import { C as CSSColorMode, n as normalizeHex, h as hexify, a as alphaCompatible, o as opacityToAlpha, b as alphaToOpacity, p as parseMode, c as normalizeColor, d as colorEqual, t as toAlphaMode, e as toNonAlphaMode, f as normalizeAlpha } from './utils-cfbe589a.js';
+import { c as connectInteractive, d as disconnectInteractive, u as updateHostInteraction, I as InteractiveContainer } from './interactive-71585ecc.js';
+import { i as isActivationKey } from './key-9a10d862.js';
+import { c as componentFocusable, s as setUpLoadableComponent, a as setComponentLoaded } from './loadable-aea90723.js';
+import { c as connectLocalized, d as disconnectLocalized } from './locale-857f39cf.js';
+import { c as clamp, a as closeToRangeEdge, r as remap } from './math-efada7a9.js';
+import { u as updateMessages, s as setUpMessages, c as connectMessages, d as disconnectMessages } from './t9n-b39c5433.js';
+import './_commonjsHelpers-3cd6d4ee.js';
+import './guid-b75a5f7b.js';
+import './resources-0f8db821.js';
+import './browser-b8d08bed.js';
+import './observers-5ba39eee.js';
+
+const colorPickerCss = ":host([disabled]){cursor:default;-webkit-user-select:none;-moz-user-select:none;user-select:none;opacity:var(--calcite-opacity-disabled)}:host([disabled]) *,:host([disabled]) ::slotted(*){pointer-events:none}:host{display:inline-block;font-size:var(--calcite-font-size--2);line-height:1rem;font-weight:var(--calcite-font-weight-normal)}:host([disabled]) ::slotted([calcite-hydrated][disabled]),:host([disabled]) [calcite-hydrated][disabled]{opacity:1}.interaction-container{display:contents}:host([scale=s]){--calcite-color-picker-spacing:8px}:host([scale=s]) .container{inline-size:160px}:host([scale=s]) .saved-colors{gap:0.25rem;grid-template-columns:repeat(auto-fill, 20px)}:host([scale=m]){--calcite-color-picker-spacing:12px}:host([scale=m]) .container{inline-size:272px}:host([scale=l]){--calcite-color-picker-spacing:16px;font-size:var(--calcite-font-size--1);line-height:1rem}:host([scale=l]) .container{inline-size:464px}:host([scale=l]) .section:first-of-type{padding-block-start:var(--calcite-color-picker-spacing)}:host([scale=l]) .saved-colors{grid-template-columns:repeat(auto-fill, 32px)}:host([scale=l]) .control-section{flex-wrap:nowrap;align-items:baseline;flex-wrap:wrap}:host([scale=l]) .color-hex-options{display:flex;flex-shrink:1;flex-direction:column;justify-content:space-around}:host([scale=l]) .color-mode-container{flex-shrink:3}.container{background-color:var(--calcite-color-foreground-1);display:inline-block;border:1px solid var(--calcite-color-border-1)}.control-and-scope{position:relative;display:flex;cursor:pointer;touch-action:none}.scope{pointer-events:none;position:absolute;z-index:var(--calcite-z-index);block-size:1px;inline-size:1px;border-radius:9999px;background-color:transparent;font-size:var(--calcite-font-size--1);outline-color:transparent}.scope:focus{outline:2px solid var(--calcite-color-brand);outline-offset:calc(\n            2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-offset-invert-focus),\n                1\n              )\n            )\n          );outline-offset:11px}.hex-and-channels-group{inline-size:100%}.hex-and-channels-group,.control-section{display:flex;flex-direction:row;flex-wrap:wrap}.section{padding-block:0 var(--calcite-color-picker-spacing);padding-inline:var(--calcite-color-picker-spacing)}.section:first-of-type{padding-block-start:var(--calcite-color-picker-spacing)}.sliders{display:flex;flex-direction:column;justify-content:space-between;margin-inline-start:var(--calcite-color-picker-spacing)}.preview-and-sliders{display:flex;align-items:center;padding:var(--calcite-color-picker-spacing)}.color-hex-options,.section--split{flex-grow:1}.header{display:flex;align-items:center;justify-content:space-between;color:var(--calcite-color-text-1)}.color-mode-container{padding-block-start:var(--calcite-color-picker-spacing)}.channels{display:flex;row-gap:0.125rem}.channel[data-channel-index=\"3\"]{inline-size:159px}:host([scale=s]) .channels{flex-wrap:wrap}:host([scale=s]) .channel{flex-basis:30%;flex-grow:1}:host([scale=s]) .channel[data-channel-index=\"3\"]{inline-size:unset;margin-inline-start:unset}:host([scale=l]) .channel[data-channel-index=\"3\"]{inline-size:131px}.saved-colors{display:grid;gap:0.5rem;padding-block-start:var(--calcite-color-picker-spacing);grid-template-columns:repeat(auto-fill, 24px)}.saved-colors-buttons{display:flex}.saved-color{outline-offset:0;outline-color:transparent;cursor:pointer}.saved-color:focus{outline:2px solid var(--calcite-color-brand);outline-offset:2px}.saved-color:hover{transition:outline-color var(--calcite-internal-animation-timing-fast) ease-in-out;outline:2px solid var(--calcite-color-border-2);outline-offset:2px}:host([hidden]){display:none}[hidden]{display:none}";
+
+const throttleFor60FpsInMs = 16;
+const ColorPicker = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.calciteColorPickerChange = createEvent(this, "calciteColorPickerChange", 6);
+        this.calciteColorPickerInput = createEvent(this, "calciteColorPickerInput", 6);
+        this.internalColorUpdateContext = null;
+        this.mode = CSSColorMode.HEX;
+        this.shiftKeyChannelAdjustment = 0;
+        this.handleTabActivate = (event) => {
+            this.channelMode = event.currentTarget.getAttribute("data-color-mode");
+            this.updateChannelsFromColor(this.color);
+        };
+        this.handleColorFieldScopeKeyDown = (event) => {
+            const { key } = event;
+            const arrowKeyToXYOffset = {
+                ArrowUp: { x: 0, y: -10 },
+                ArrowRight: { x: 10, y: 0 },
+                ArrowDown: { x: 0, y: 10 },
+                ArrowLeft: { x: -10, y: 0 },
+            };
+            if (arrowKeyToXYOffset[key]) {
+                event.preventDefault();
+                this.scopeOrientation = key === "ArrowDown" || key === "ArrowUp" ? "vertical" : "horizontal";
+                this.captureColorFieldColor(this.colorFieldScopeLeft + arrowKeyToXYOffset[key].x || 0, this.colorFieldScopeTop + arrowKeyToXYOffset[key].y || 0, false);
+            }
+        };
+        this.handleHueScopeKeyDown = (event) => {
+            const modifier = event.shiftKey ? 10 : 1;
+            const { key } = event;
+            const arrowKeyToXOffset = {
+                ArrowUp: 1,
+                ArrowRight: 1,
+                ArrowDown: -1,
+                ArrowLeft: -1,
+            };
+            if (arrowKeyToXOffset[key]) {
+                event.preventDefault();
+                const delta = arrowKeyToXOffset[key] * modifier;
+                const hue = this.baseColorFieldColor.hue();
+                const color = this.baseColorFieldColor.hue(hue + delta);
+                this.internalColorSet(color, false);
+            }
+        };
+        this.handleHexInputChange = (event) => {
+            event.stopPropagation();
+            const { allowEmpty, color: color$1 } = this;
+            const input = event.target;
+            const hex = input.value;
+            if (allowEmpty && !hex) {
+                this.internalColorSet(null);
+                return;
+            }
+            const normalizedHex = color$1 && normalizeHex(hexify(color$1, alphaCompatible(this.mode)));
+            if (hex !== normalizedHex) {
+                this.internalColorSet(color(hex));
+            }
+        };
+        this.handleSavedColorSelect = (event) => {
+            const swatch = event.currentTarget;
+            this.internalColorSet(color(swatch.color));
+        };
+        this.handleChannelInput = (event) => {
+            const input = event.currentTarget;
+            const channelIndex = Number(input.getAttribute("data-channel-index"));
+            const isAlphaChannel = channelIndex === 3;
+            const limit = isAlphaChannel
+                ? OPACITY_LIMITS.max
+                : this.channelMode === "rgb"
+                    ? RGB_LIMITS[Object.keys(RGB_LIMITS)[channelIndex]]
+                    : HSV_LIMITS[Object.keys(HSV_LIMITS)[channelIndex]];
+            let inputValue;
+            if (this.allowEmpty && !input.value) {
+                inputValue = "";
+            }
+            else {
+                const value = Number(input.value);
+                const adjustedValue = value + this.shiftKeyChannelAdjustment;
+                const clamped = clamp(adjustedValue, 0, limit);
+                inputValue = clamped.toString();
+            }
+            input.value = inputValue;
+            if (inputValue !== "" && this.shiftKeyChannelAdjustment !== 0) {
+                // we treat nudging as a change event since the input won't emit when modifying the value directly
+                this.handleChannelChange(event);
+            }
+        };
+        this.handleChannelChange = (event) => {
+            const input = event.currentTarget;
+            const channelIndex = Number(input.getAttribute("data-channel-index"));
+            const channels = [...this.channels];
+            const shouldClearChannels = this.allowEmpty && !input.value;
+            if (shouldClearChannels) {
+                this.channels = [null, null, null, null];
+                this.internalColorSet(null);
+                return;
+            }
+            const isAlphaChannel = channelIndex === 3;
+            const value = Number(input.value);
+            channels[channelIndex] = isAlphaChannel ? opacityToAlpha(value) : value;
+            this.updateColorFromChannels(channels);
+        };
+        this.handleSavedColorKeyDown = (event) => {
+            if (isActivationKey(event.key)) {
+                event.preventDefault();
+                this.handleSavedColorSelect(event);
+            }
+        };
+        this.handleColorFieldPointerDown = (event) => {
+            if (!isPrimaryPointerButton(event)) {
+                return;
+            }
+            const { offsetX, offsetY } = event;
+            window.addEventListener("pointermove", this.globalPointerMoveHandler);
+            window.addEventListener("pointerup", this.globalPointerUpHandler, { once: true });
+            this.activeCanvasInfo = {
+                context: this.colorFieldRenderingContext,
+                bounds: this.colorFieldRenderingContext.canvas.getBoundingClientRect(),
+            };
+            this.captureColorFieldColor(offsetX, offsetY);
+            this.colorFieldScopeNode.focus();
+        };
+        this.handleHueSliderPointerDown = (event) => {
+            if (!isPrimaryPointerButton(event)) {
+                return;
+            }
+            const { offsetX } = event;
+            window.addEventListener("pointermove", this.globalPointerMoveHandler);
+            window.addEventListener("pointerup", this.globalPointerUpHandler, { once: true });
+            this.activeCanvasInfo = {
+                context: this.hueSliderRenderingContext,
+                bounds: this.hueSliderRenderingContext.canvas.getBoundingClientRect(),
+            };
+            this.captureHueSliderColor(offsetX);
+            this.hueScopeNode.focus();
+        };
+        this.handleOpacitySliderPointerDown = (event) => {
+            if (!isPrimaryPointerButton(event)) {
+                return;
+            }
+            const { offsetX } = event;
+            window.addEventListener("pointermove", this.globalPointerMoveHandler);
+            window.addEventListener("pointerup", this.globalPointerUpHandler, { once: true });
+            this.activeCanvasInfo = {
+                context: this.opacitySliderRenderingContext,
+                bounds: this.opacitySliderRenderingContext.canvas.getBoundingClientRect(),
+            };
+            this.captureOpacitySliderValue(offsetX);
+            this.opacityScopeNode.focus();
+        };
+        this.globalPointerUpHandler = (event) => {
+            if (!isPrimaryPointerButton(event)) {
+                return;
+            }
+            const previouslyDragging = this.activeCanvasInfo;
+            this.activeCanvasInfo = null;
+            this.drawColorControls();
+            if (previouslyDragging) {
+                this.calciteColorPickerChange.emit();
+            }
+        };
+        this.globalPointerMoveHandler = (event) => {
+            const { activeCanvasInfo, el } = this;
+            if (!el.isConnected || !activeCanvasInfo) {
+                return;
+            }
+            const { context, bounds } = activeCanvasInfo;
+            let samplingX;
+            let samplingY;
+            const { clientX, clientY } = event;
+            if (context.canvas.matches(":hover")) {
+                samplingX = clientX - bounds.x;
+                samplingY = clientY - bounds.y;
+            }
+            else {
+                // snap x and y to the closest edge
+                if (clientX < bounds.x + bounds.width && clientX > bounds.x) {
+                    samplingX = clientX - bounds.x;
+                }
+                else if (clientX < bounds.x) {
+                    samplingX = 0;
+                }
+                else {
+                    samplingX = bounds.width;
+                }
+                if (clientY < bounds.y + bounds.height && clientY > bounds.y) {
+                    samplingY = clientY - bounds.y;
+                }
+                else if (clientY < bounds.y) {
+                    samplingY = 0;
+                }
+                else {
+                    samplingY = bounds.height;
+                }
+            }
+            if (context === this.colorFieldRenderingContext) {
+                this.captureColorFieldColor(samplingX, samplingY, false);
+            }
+            else if (context === this.hueSliderRenderingContext) {
+                this.captureHueSliderColor(samplingX);
+            }
+            else if (context === this.opacitySliderRenderingContext) {
+                this.captureOpacitySliderValue(samplingX);
+            }
+        };
+        this.storeColorFieldScope = (node) => {
+            this.colorFieldScopeNode = node;
+        };
+        this.storeHueScope = (node) => {
+            this.hueScopeNode = node;
+        };
+        this.renderChannelsTabTitle = (channelMode) => {
+            const { channelMode: activeChannelMode, messages } = this;
+            const selected = channelMode === activeChannelMode;
+            const label = channelMode === "rgb" ? messages.rgb : messages.hsv;
+            return (h("calcite-tab-title", { class: CSS.colorMode, "data-color-mode": channelMode, key: channelMode, onCalciteTabsActivate: this.handleTabActivate, selected: selected }, label));
+        };
+        this.renderChannelsTab = (channelMode) => {
+            const { allowEmpty, channelMode: activeChannelMode, channels, messages, alphaChannel } = this;
+            const selected = channelMode === activeChannelMode;
+            const isRgb = channelMode === "rgb";
+            const channelAriaLabels = isRgb
+                ? [messages.red, messages.green, messages.blue]
+                : [messages.hue, messages.saturation, messages.value];
+            const direction = getElementDir(this.el);
+            const channelsToRender = alphaChannel ? channels : channels.slice(0, 3);
+            return (h("calcite-tab", { class: CSS.control, key: channelMode, selected: selected }, h("div", { class: CSS.channels, dir: "ltr" }, channelsToRender.map((channelValue, index) => {
+                const isAlphaChannel = index === 3;
+                if (isAlphaChannel) {
+                    channelValue =
+                        allowEmpty && !channelValue ? channelValue : alphaToOpacity(channelValue);
+                }
+                /* the channel container is ltr, so we apply the host's direction */
+                return this.renderChannel(channelValue, index, channelAriaLabels[index], direction, isAlphaChannel ? "%" : "");
+            }))));
+        };
+        this.renderChannel = (value, index, ariaLabel, direction, suffix) => {
+            return (h("calcite-input-number", { class: CSS.channel, "data-channel-index": index, dir: direction, key: index, label: ariaLabel, lang: this.effectiveLocale, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputNumberChange: this.handleChannelChange, onCalciteInputNumberInput: this.handleChannelInput, onKeyDown: this.handleKeyDown, scale: this.scale === "l" ? "m" : "s",
+                // workaround to ensure input borders overlap as desired
+                // this is because the build transforms margin-left to its
+                // logical-prop, which is undesired as channels are always ltr
+                style: {
+                    marginLeft: index > 0 && !(this.scale === "s" && this.alphaChannel && index === 3) ? "-1px" : "",
+                }, suffixText: suffix, value: value === null || value === void 0 ? void 0 : value.toString() }));
+        };
+        this.deleteColor = () => {
+            const colorToDelete = hexify(this.color, this.alphaChannel);
+            const inStorage = this.savedColors.indexOf(colorToDelete) > -1;
+            if (!inStorage) {
+                return;
+            }
+            const savedColors = this.savedColors.filter((color) => color !== colorToDelete);
+            this.savedColors = savedColors;
+            const storageKey = `${DEFAULT_STORAGE_KEY_PREFIX}${this.storageId}`;
+            if (this.storageId) {
+                localStorage.setItem(storageKey, JSON.stringify(savedColors));
+            }
+        };
+        this.saveColor = () => {
+            const colorToSave = hexify(this.color, this.alphaChannel);
+            const alreadySaved = this.savedColors.indexOf(colorToSave) > -1;
+            if (alreadySaved) {
+                return;
+            }
+            const savedColors = [...this.savedColors, colorToSave];
+            this.savedColors = savedColors;
+            const storageKey = `${DEFAULT_STORAGE_KEY_PREFIX}${this.storageId}`;
+            if (this.storageId) {
+                localStorage.setItem(storageKey, JSON.stringify(savedColors));
+            }
+        };
+        this.drawColorControls = throttle((type = "all") => {
+            if ((type === "all" || type === "color-field") && this.colorFieldRenderingContext) {
+                this.drawColorField();
+            }
+            if ((type === "all" || type === "hue-slider") && this.hueSliderRenderingContext) {
+                this.drawHueSlider();
+            }
+            if (this.alphaChannel &&
+                (type === "all" || type === "opacity-slider") &&
+                this.opacitySliderRenderingContext) {
+                this.drawOpacitySlider();
+            }
+        }, throttleFor60FpsInMs);
+        this.captureColorFieldColor = (x, y, skipEqual = true) => {
+            const { dimensions: { colorField: { height, width }, }, } = this;
+            const saturation = Math.round((HSV_LIMITS.s / width) * x);
+            const value = Math.round((HSV_LIMITS.v / height) * (height - y));
+            this.internalColorSet(this.baseColorFieldColor.hsv().saturationv(saturation).value(value), skipEqual);
+        };
+        this.initColorField = (canvas) => {
+            this.colorFieldRenderingContext = canvas.getContext("2d");
+            this.updateCanvasSize("color-field");
+            this.drawColorControls();
+        };
+        this.initHueSlider = (canvas) => {
+            this.hueSliderRenderingContext = canvas.getContext("2d");
+            this.updateCanvasSize("hue-slider");
+            this.drawHueSlider();
+        };
+        this.initOpacitySlider = (canvas) => {
+            if (!canvas) {
+                return;
+            }
+            this.opacitySliderRenderingContext = canvas.getContext("2d");
+            this.updateCanvasSize("opacity-slider");
+            this.drawOpacitySlider();
+        };
+        this.storeOpacityScope = (node) => {
+            this.opacityScopeNode = node;
+        };
+        this.handleOpacityScopeKeyDown = (event) => {
+            const modifier = event.shiftKey ? 10 : 1;
+            const { key } = event;
+            const arrowKeyToXOffset = {
+                ArrowUp: 0.01,
+                ArrowRight: 0.01,
+                ArrowDown: -0.01,
+                ArrowLeft: -0.01,
+            };
+            if (arrowKeyToXOffset[key]) {
+                event.preventDefault();
+                const delta = arrowKeyToXOffset[key] * modifier;
+                const alpha = this.baseColorFieldColor.alpha();
+                const color = this.baseColorFieldColor.alpha(alpha + delta);
+                this.internalColorSet(color, false);
+            }
+        };
+        this.allowEmpty = false;
+        this.alphaChannel = false;
+        this.channelsDisabled = false;
+        this.color = DEFAULT_COLOR;
+        this.disabled = false;
+        this.format = "auto";
+        this.hideChannels = false;
+        this.hexDisabled = false;
+        this.hideHex = false;
+        this.hideSaved = false;
+        this.savedDisabled = false;
+        this.scale = "m";
+        this.storageId = undefined;
+        this.messageOverrides = undefined;
+        this.numberingSystem = undefined;
+        this.value = normalizeHex(hexify(DEFAULT_COLOR, this.alphaChannel));
+        this.defaultMessages = undefined;
+        this.channelMode = "rgb";
+        this.channels = this.toChannels(DEFAULT_COLOR);
+        this.dimensions = DIMENSIONS.m;
+        this.effectiveLocale = "";
+        this.messages = undefined;
+        this.savedColors = [];
+        this.colorFieldScopeTop = undefined;
+        this.colorFieldScopeLeft = undefined;
+        this.hueScopeLeft = undefined;
+        this.opacityScopeLeft = undefined;
+        this.scopeOrientation = undefined;
+    }
+    handleAlphaChannelChange(alphaChannel) {
+        const { format } = this;
+        if (alphaChannel && format !== "auto" && !alphaCompatible(format)) {
+            console.warn(`ignoring alphaChannel as the current format (${format}) does not support alpha`);
+            this.alphaChannel = false;
+        }
+    }
+    handleColorChange(color, oldColor) {
+        this.drawColorControls();
+        this.updateChannelsFromColor(color);
+        this.previousColor = oldColor;
+    }
+    handleFormatOrAlphaChannelChange() {
+        this.setMode(this.format);
+        this.internalColorSet(this.color, false, "internal");
+    }
+    handleScaleChange(scale = "m") {
+        this.updateDimensions(scale);
+        this.updateCanvasSize("all");
+        this.drawColorControls();
+    }
+    onMessagesChange() {
+        /* wired up by t9n util */
+    }
+    handleValueChange(value, oldValue) {
+        const { allowEmpty, format } = this;
+        const checkMode = !allowEmpty || value;
+        let modeChanged = false;
+        if (checkMode) {
+            const nextMode = parseMode(value);
+            if (!nextMode || (format !== "auto" && nextMode !== format)) {
+                this.showIncompatibleColorWarning(value, format);
+                this.value = oldValue;
+                return;
+            }
+            modeChanged = this.mode !== nextMode;
+            this.setMode(nextMode, this.internalColorUpdateContext === null);
+        }
+        const dragging = this.activeCanvasInfo;
+        if (this.internalColorUpdateContext === "initial") {
+            return;
+        }
+        if (this.internalColorUpdateContext === "user-interaction") {
+            this.calciteColorPickerInput.emit();
+            if (!dragging) {
+                this.calciteColorPickerChange.emit();
+            }
+            return;
+        }
+        const color$1 = allowEmpty && !value
+            ? null
+            : color(value != null && typeof value === "object" && alphaCompatible(this.mode)
+                ? normalizeColor(value)
+                : value);
+        const colorChanged = !colorEqual(color$1, this.color);
+        if (modeChanged || colorChanged) {
+            this.internalColorSet(color$1, this.alphaChannel && !(this.mode.endsWith("a") || this.mode.endsWith("a-css")), "internal");
+        }
+    }
+    get baseColorFieldColor() {
+        return this.color || this.previousColor || DEFAULT_COLOR;
+    }
+    effectiveLocaleChange() {
+        updateMessages(this, this.effectiveLocale);
+    }
+    // using @Listen as a workaround for VDOM listener not firing
+    handleChannelKeyUpOrDown(event) {
+        this.shiftKeyChannelAdjustment = 0;
+        const { key } = event;
+        if ((key !== "ArrowUp" && key !== "ArrowDown") ||
+            !event.composedPath().some((node) => { var _a; return (_a = node.classList) === null || _a === void 0 ? void 0 : _a.contains(CSS.channel); })) {
+            return;
+        }
+        const { shiftKey } = event;
+        event.preventDefault();
+        if (!this.color) {
+            this.internalColorSet(this.previousColor);
+            event.stopPropagation();
+            return;
+        }
+        // this gets applied to the input's up/down arrow increment/decrement
+        const complementaryBump = 9;
+        this.shiftKeyChannelAdjustment =
+            key === "ArrowUp" && shiftKey
+                ? complementaryBump
+                : key === "ArrowDown" && shiftKey
+                    ? -complementaryBump
+                    : 0;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    //--------------------------------------------------------------------------
+    /** Sets focus on the component's first focusable element. */
+    async setFocus() {
+        await componentFocusable(this);
+        this.el.focus();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentWillLoad() {
+        setUpLoadableComponent(this);
+        const { allowEmpty, color: color$1, format, value } = this;
+        const willSetNoColor = allowEmpty && !value;
+        const parsedMode = parseMode(value);
+        const valueIsCompatible = willSetNoColor || (format === "auto" && parsedMode) || format === parsedMode;
+        const initialColor = willSetNoColor ? null : valueIsCompatible ? color(value) : color$1;
+        if (!valueIsCompatible) {
+            this.showIncompatibleColorWarning(value, format);
+        }
+        this.setMode(format, false);
+        this.internalColorSet(initialColor, false, "initial");
+        this.updateDimensions(this.scale);
+        const storageKey = `${DEFAULT_STORAGE_KEY_PREFIX}${this.storageId}`;
+        if (this.storageId && localStorage.getItem(storageKey)) {
+            this.savedColors = JSON.parse(localStorage.getItem(storageKey));
+        }
+        await setUpMessages(this);
+    }
+    connectedCallback() {
+        connectInteractive(this);
+        connectLocalized(this);
+        connectMessages(this);
+    }
+    componentDidLoad() {
+        setComponentLoaded(this);
+    }
+    disconnectedCallback() {
+        window.removeEventListener("pointermove", this.globalPointerMoveHandler);
+        window.removeEventListener("pointerup", this.globalPointerUpHandler);
+        disconnectInteractive(this);
+        disconnectLocalized(this);
+        disconnectMessages(this);
+    }
+    componentDidRender() {
+        updateHostInteraction(this);
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Render Methods
+    //
+    //--------------------------------------------------------------------------
+    render() {
+        const { allowEmpty, channelsDisabled, color, colorFieldScopeLeft, colorFieldScopeTop, dimensions: { slider: { width: sliderWidth }, thumb: { radius: thumbRadius }, }, hexDisabled, hideChannels, hideHex, hideSaved, hueScopeLeft, messages, alphaChannel, opacityScopeLeft, savedColors, savedDisabled, scale, scopeOrientation, } = this;
+        const selectedColorInHex = color ? hexify(color, alphaChannel) : null;
+        const hueTop = thumbRadius;
+        const hueLeft = hueScopeLeft !== null && hueScopeLeft !== void 0 ? hueScopeLeft : (sliderWidth * DEFAULT_COLOR.hue()) / HSV_LIMITS.h;
+        const opacityTop = thumbRadius;
+        const opacityLeft = opacityScopeLeft !== null && opacityScopeLeft !== void 0 ? opacityScopeLeft : (sliderWidth * alphaToOpacity(DEFAULT_COLOR.alpha())) / OPACITY_LIMITS.max;
+        const noColor = color === null;
+        const vertical = scopeOrientation === "vertical";
+        const noHex = hexDisabled || hideHex;
+        const noChannels = channelsDisabled || hideChannels;
+        const noSaved = savedDisabled || hideSaved;
+        const [adjustedColorFieldScopeLeft, adjustedColorFieldScopeTop] = this.getAdjustedScopePosition(colorFieldScopeLeft, colorFieldScopeTop);
+        const [adjustedHueScopeLeft, adjustedHueScopeTop] = this.getAdjustedScopePosition(hueLeft, hueTop);
+        const [adjustedOpacityScopeLeft, adjustedOpacityScopeTop] = this.getAdjustedScopePosition(opacityLeft, opacityTop);
+        return (h(InteractiveContainer, { disabled: this.disabled }, h("div", { class: CSS.container }, h("div", { class: CSS.controlAndScope }, h("canvas", { class: CSS.colorField, onPointerDown: this.handleColorFieldPointerDown,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.initColorField }), h("div", { "aria-label": vertical ? messages.value : messages.saturation, "aria-valuemax": vertical ? HSV_LIMITS.v : HSV_LIMITS.s, "aria-valuemin": "0", "aria-valuenow": (vertical ? color === null || color === void 0 ? void 0 : color.saturationv() : color === null || color === void 0 ? void 0 : color.value()) || "0", class: { [CSS.scope]: true, [CSS.colorFieldScope]: true }, onKeyDown: this.handleColorFieldScopeKeyDown, role: "slider", style: {
+                top: `${adjustedColorFieldScopeTop || 0}px`,
+                left: `${adjustedColorFieldScopeLeft || 0}px`,
+            }, tabindex: "0",
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.storeColorFieldScope })), h("div", { class: CSS.previewAndSliders }, h("calcite-color-picker-swatch", { class: CSS.preview, color: selectedColorInHex, scale: "l" }), h("div", { class: CSS.sliders }, h("div", { class: CSS.controlAndScope }, h("canvas", { class: { [CSS.slider]: true, [CSS.hueSlider]: true }, onPointerDown: this.handleHueSliderPointerDown,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.initHueSlider }), h("div", { "aria-label": messages.hue, "aria-valuemax": HSV_LIMITS.h, "aria-valuemin": "0", "aria-valuenow": (color === null || color === void 0 ? void 0 : color.round().hue()) || DEFAULT_COLOR.round().hue(), class: { [CSS.scope]: true, [CSS.hueScope]: true }, onKeyDown: this.handleHueScopeKeyDown, role: "slider", style: {
+                top: `${adjustedHueScopeTop}px`,
+                left: `${adjustedHueScopeLeft}px`,
+            }, tabindex: "0",
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.storeHueScope })), alphaChannel ? (h("div", { class: CSS.controlAndScope }, h("canvas", { class: { [CSS.slider]: true, [CSS.opacitySlider]: true }, onPointerDown: this.handleOpacitySliderPointerDown,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.initOpacitySlider }), h("div", { "aria-label": messages.opacity, "aria-valuemax": OPACITY_LIMITS.max, "aria-valuemin": OPACITY_LIMITS.min, "aria-valuenow": (color || DEFAULT_COLOR).round().alpha(), class: { [CSS.scope]: true, [CSS.opacityScope]: true }, onKeyDown: this.handleOpacityScopeKeyDown, role: "slider", style: {
+                top: `${adjustedOpacityScopeTop}px`,
+                left: `${adjustedOpacityScopeLeft}px`,
+            }, tabindex: "0",
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.storeOpacityScope }))) : null)), noHex && noChannels ? null : (h("div", { class: {
+                [CSS.controlSection]: true,
+                [CSS.section]: true,
+            } }, h("div", { class: CSS.hexAndChannelsGroup }, noHex ? null : (h("div", { class: CSS.hexOptions }, h("calcite-color-picker-hex-input", { allowEmpty: allowEmpty, alphaChannel: alphaChannel, class: CSS.control, messages: messages, numberingSystem: this.numberingSystem, onCalciteColorPickerHexInputChange: this.handleHexInputChange, scale: scale, value: selectedColorInHex }))), noChannels ? null : (h("calcite-tabs", { class: {
+                [CSS.colorModeContainer]: true,
+                [CSS.splitSection]: true,
+            }, scale: scale === "l" ? "m" : "s" }, h("calcite-tab-nav", { slot: "title-group" }, this.renderChannelsTabTitle("rgb"), this.renderChannelsTabTitle("hsv")), this.renderChannelsTab("rgb"), this.renderChannelsTab("hsv")))))), noSaved ? null : (h("div", { class: { [CSS.savedColorsSection]: true, [CSS.section]: true } }, h("div", { class: CSS.header }, h("label", null, messages.saved), h("div", { class: CSS.savedColorsButtons }, h("calcite-button", { appearance: "transparent", class: CSS.deleteColor, disabled: noColor, iconStart: "minus", kind: "neutral", label: messages.deleteColor, onClick: this.deleteColor, scale: scale, type: "button" }), h("calcite-button", { appearance: "transparent", class: CSS.saveColor, disabled: noColor, iconStart: "plus", kind: "neutral", label: messages.saveColor, onClick: this.saveColor, scale: scale, type: "button" }))), savedColors.length > 0 ? (h("div", { class: CSS.savedColors }, [
+            ...savedColors.map((color) => (h("calcite-color-picker-swatch", { class: CSS.savedColor, color: color, key: color, onClick: this.handleSavedColorSelect, onKeyDown: this.handleSavedColorKeyDown, scale: scale, tabIndex: 0 }))),
+        ])) : null)))));
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    handleKeyDown(event) {
+        if (event.key === "Enter") {
+            event.preventDefault();
+        }
+    }
+    showIncompatibleColorWarning(value, format) {
+        console.warn(`ignoring color value (${value}) as it is not compatible with the current format (${format})`);
+    }
+    setMode(format, warn = true) {
+        const mode = format === "auto" ? this.mode : format;
+        this.mode = this.ensureCompatibleMode(mode, warn);
+    }
+    ensureCompatibleMode(mode, warn) {
+        const { alphaChannel } = this;
+        const isAlphaCompatible = alphaCompatible(mode);
+        if (alphaChannel && !isAlphaCompatible) {
+            const alphaMode = toAlphaMode(mode);
+            if (warn) {
+                console.warn(`setting format to (${alphaMode}) as the provided one (${mode}) does not support alpha`);
+            }
+            return alphaMode;
+        }
+        if (!alphaChannel && isAlphaCompatible) {
+            const nonAlphaMode = toNonAlphaMode(mode);
+            if (warn) {
+                console.warn(`setting format to (${nonAlphaMode}) as the provided one (${mode}) does not support alpha`);
+            }
+            return nonAlphaMode;
+        }
+        return mode;
+    }
+    captureHueSliderColor(x) {
+        const { dimensions: { slider: { width }, }, } = this;
+        const hue = (HUE_LIMIT_CONSTRAINED / width) * x;
+        this.internalColorSet(this.baseColorFieldColor.hue(hue), false);
+    }
+    captureOpacitySliderValue(x) {
+        const { dimensions: { slider: { width }, }, } = this;
+        const alpha = opacityToAlpha((OPACITY_LIMITS.max / width) * x);
+        this.internalColorSet(this.baseColorFieldColor.alpha(alpha), false);
+    }
+    internalColorSet(color, skipEqual = true, context = "user-interaction") {
+        if (skipEqual && colorEqual(color, this.color)) {
+            return;
+        }
+        this.internalColorUpdateContext = context;
+        this.color = color;
+        this.value = this.toValue(color);
+        this.internalColorUpdateContext = null;
+    }
+    toValue(color, format = this.mode) {
+        if (!color) {
+            return null;
+        }
+        const hexMode = "hex";
+        if (format.includes(hexMode)) {
+            const hasAlpha = format === CSSColorMode.HEXA;
+            return normalizeHex(hexify(color.round(), hasAlpha), hasAlpha);
+        }
+        if (format.includes("-css")) {
+            const value = color[format.replace("-css", "").replace("a", "")]().round().string();
+            // Color omits alpha values when alpha is 1
+            const needToInjectAlpha = (format.endsWith("a") || format.endsWith("a-css")) && color.alpha() === 1;
+            if (needToInjectAlpha) {
+                const model = value.slice(0, 3);
+                const values = value.slice(4, -1);
+                return `${model}a(${values}, ${color.alpha()})`;
+            }
+            return value;
+        }
+        const colorObject = 
+        /* Color() does not support hsva, hsla nor rgba, so we use the non-alpha mode */
+        color[toNonAlphaMode(format)]().round().object();
+        if (format.endsWith("a")) {
+            return normalizeAlpha(colorObject);
+        }
+        return colorObject;
+    }
+    getSliderCapSpacing() {
+        const { dimensions: { slider: { height }, thumb: { radius }, }, } = this;
+        return radius * 2 - height;
+    }
+    updateDimensions(scale = "m") {
+        this.dimensions = DIMENSIONS[scale];
+    }
+    drawColorField() {
+        const context = this.colorFieldRenderingContext;
+        const { dimensions: { colorField: { height, width }, }, } = this;
+        context.fillStyle = this.baseColorFieldColor
+            .hsv()
+            .saturationv(100)
+            .value(100)
+            .alpha(1)
+            .string();
+        context.fillRect(0, 0, width, height);
+        const whiteGradient = context.createLinearGradient(0, 0, width, 0);
+        whiteGradient.addColorStop(0, "rgba(255,255,255,1)");
+        whiteGradient.addColorStop(1, "rgba(255,255,255,0)");
+        context.fillStyle = whiteGradient;
+        context.fillRect(0, 0, width, height);
+        const blackGradient = context.createLinearGradient(0, 0, 0, height);
+        blackGradient.addColorStop(0, "rgba(0,0,0,0)");
+        blackGradient.addColorStop(1, "rgba(0,0,0,1)");
+        context.fillStyle = blackGradient;
+        context.fillRect(0, 0, width, height);
+        this.drawActiveColorFieldColor();
+    }
+    setCanvasContextSize(canvas, { height, width }) {
+        if (!canvas) {
+            return;
+        }
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        canvas.width = width * devicePixelRatio;
+        canvas.height = height * devicePixelRatio;
+        canvas.style.height = `${height}px`;
+        canvas.style.width = `${width}px`;
+        const context = canvas.getContext("2d");
+        context.scale(devicePixelRatio, devicePixelRatio);
+    }
+    updateCanvasSize(context = "all") {
+        var _a, _b, _c;
+        const { dimensions } = this;
+        if (context === "all" || context === "color-field") {
+            this.setCanvasContextSize((_a = this.colorFieldRenderingContext) === null || _a === void 0 ? void 0 : _a.canvas, dimensions.colorField);
+        }
+        const adjustedSliderDimensions = {
+            width: dimensions.slider.width,
+            height: dimensions.slider.height + (dimensions.thumb.radius - dimensions.slider.height / 2) * 2,
+        };
+        if (context === "all" || context === "hue-slider") {
+            this.setCanvasContextSize((_b = this.hueSliderRenderingContext) === null || _b === void 0 ? void 0 : _b.canvas, adjustedSliderDimensions);
+        }
+        if (context === "all" || context === "opacity-slider") {
+            this.setCanvasContextSize((_c = this.opacitySliderRenderingContext) === null || _c === void 0 ? void 0 : _c.canvas, adjustedSliderDimensions);
+        }
+    }
+    drawActiveColorFieldColor() {
+        const { color } = this;
+        if (!color) {
+            return;
+        }
+        const hsvColor = color.hsv();
+        const { dimensions: { colorField: { height, width }, thumb: { radius }, }, } = this;
+        const x = hsvColor.saturationv() / (HSV_LIMITS.s / width);
+        const y = height - hsvColor.value() / (HSV_LIMITS.v / height);
+        requestAnimationFrame(() => {
+            this.colorFieldScopeLeft = x;
+            this.colorFieldScopeTop = y;
+        });
+        this.drawThumb(this.colorFieldRenderingContext, radius, x, y, hsvColor);
+    }
+    drawThumb(context, radius, x, y, color) {
+        const startAngle = 0;
+        const endAngle = 2 * Math.PI;
+        const outlineWidth = 1;
+        context.beginPath();
+        context.arc(x, y, radius, startAngle, endAngle);
+        context.fillStyle = "#fff";
+        context.fill();
+        context.strokeStyle = "rgba(0,0,0,0.3)";
+        context.lineWidth = outlineWidth;
+        context.stroke();
+        context.beginPath();
+        context.arc(x, y, radius - 3, startAngle, endAngle);
+        context.fillStyle = color.rgb().alpha(1).string();
+        context.fill();
+    }
+    drawActiveHueSliderColor() {
+        const { color } = this;
+        if (!color) {
+            return;
+        }
+        const hsvColor = color.hsv().saturationv(100).value(100);
+        const { dimensions: { slider: { width }, thumb: { radius }, }, } = this;
+        const x = hsvColor.hue() / (HUE_LIMIT_CONSTRAINED / width);
+        const y = radius;
+        const sliderBoundX = this.getSliderBoundX(x, width, radius);
+        requestAnimationFrame(() => {
+            this.hueScopeLeft = sliderBoundX;
+        });
+        this.drawThumb(this.hueSliderRenderingContext, radius, sliderBoundX, y, hsvColor);
+    }
+    drawHueSlider() {
+        const context = this.hueSliderRenderingContext;
+        const { dimensions: { slider: { height, width }, thumb: { radius: thumbRadius }, }, } = this;
+        const x = 0;
+        const y = thumbRadius - height / 2;
+        const gradient = context.createLinearGradient(0, 0, width, 0);
+        const hueSliderColorStopKeywords = [
+            "red",
+            "yellow",
+            "lime",
+            "cyan",
+            "blue",
+            "magenta",
+            "#ff0004" /* 1 unit less than #ff0 to avoid duplicate values within range */,
+        ];
+        const offset = 1 / (hueSliderColorStopKeywords.length - 1);
+        let currentOffset = 0;
+        hueSliderColorStopKeywords.forEach((keyword) => {
+            gradient.addColorStop(currentOffset, color(keyword).string());
+            currentOffset += offset;
+        });
+        context.clearRect(0, 0, width, height + this.getSliderCapSpacing() * 2);
+        this.drawSliderPath(context, height, width, x, y);
+        context.fillStyle = gradient;
+        context.fill();
+        context.strokeStyle = "rgba(0,0,0,0.3)";
+        context.lineWidth = 1;
+        context.stroke();
+        this.drawActiveHueSliderColor();
+    }
+    drawOpacitySlider() {
+        const context = this.opacitySliderRenderingContext;
+        const { baseColorFieldColor: previousColor, dimensions: { slider: { height, width }, thumb: { radius: thumbRadius }, }, } = this;
+        const x = 0;
+        const y = thumbRadius - height / 2;
+        context.clearRect(0, 0, width, height + this.getSliderCapSpacing() * 2);
+        const gradient = context.createLinearGradient(0, y, width, 0);
+        const startColor = previousColor.rgb().alpha(0);
+        const midColor = previousColor.rgb().alpha(0.5);
+        const endColor = previousColor.rgb().alpha(1);
+        gradient.addColorStop(0, startColor.string());
+        gradient.addColorStop(0.5, midColor.string());
+        gradient.addColorStop(1, endColor.string());
+        this.drawSliderPath(context, height, width, x, y);
+        const pattern = context.createPattern(this.getCheckeredBackgroundPattern(), "repeat");
+        context.fillStyle = pattern;
+        context.fill();
+        context.fillStyle = gradient;
+        context.fill();
+        context.strokeStyle = "rgba(0,0,0,0.3)";
+        context.lineWidth = 1;
+        context.stroke();
+        this.drawActiveOpacitySliderColor();
+    }
+    drawSliderPath(context, height, width, x, y) {
+        const radius = height / 2 + 1;
+        context.beginPath();
+        context.moveTo(x + radius, y);
+        context.lineTo(x + width - radius, y);
+        context.quadraticCurveTo(x + width, y, x + width, y + radius);
+        context.lineTo(x + width, y + height - radius);
+        context.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+        context.lineTo(x + radius, y + height);
+        context.quadraticCurveTo(x, y + height, x, y + height - radius);
+        context.lineTo(x, y + radius);
+        context.quadraticCurveTo(x, y, x + radius, y);
+        context.closePath();
+    }
+    getCheckeredBackgroundPattern() {
+        if (this.checkerPattern) {
+            return this.checkerPattern;
+        }
+        const pattern = document.createElement("canvas");
+        pattern.width = 10;
+        pattern.height = 10;
+        const patternContext = pattern.getContext("2d");
+        patternContext.fillStyle = "#ccc";
+        patternContext.fillRect(0, 0, 10, 10);
+        patternContext.fillStyle = "#fff";
+        patternContext.fillRect(0, 0, 5, 5);
+        patternContext.fillRect(5, 5, 5, 5);
+        this.checkerPattern = pattern;
+        return pattern;
+    }
+    drawActiveOpacitySliderColor() {
+        const { color } = this;
+        if (!color) {
+            return;
+        }
+        const hsvColor = color;
+        const { dimensions: { slider: { width }, thumb: { radius }, }, } = this;
+        const x = alphaToOpacity(hsvColor.alpha()) / (OPACITY_LIMITS.max / width);
+        const y = radius;
+        const sliderBoundX = this.getSliderBoundX(x, width, radius);
+        requestAnimationFrame(() => {
+            this.opacityScopeLeft = sliderBoundX;
+        });
+        this.drawThumb(this.opacitySliderRenderingContext, radius, sliderBoundX, y, hsvColor);
+    }
+    getSliderBoundX(x, width, radius) {
+        const closeToEdge = closeToRangeEdge(x, width, radius);
+        return closeToEdge === 0
+            ? x
+            : closeToEdge === -1
+                ? remap(x, 0, width, radius, radius * 2)
+                : remap(x, 0, width, width - radius * 2, width - radius);
+    }
+    updateColorFromChannels(channels) {
+        this.internalColorSet(color(channels, this.channelMode));
+    }
+    updateChannelsFromColor(color) {
+        this.channels = color ? this.toChannels(color) : [null, null, null, null];
+    }
+    toChannels(color) {
+        const { channelMode } = this;
+        const channels = color[channelMode]()
+            .array()
+            .map((value, index) => {
+            const isAlpha = index === 3;
+            return isAlpha ? value : Math.floor(value);
+        });
+        if (channels.length === 3) {
+            channels.push(1); // Color omits alpha when 1
+        }
+        return channels;
+    }
+    getAdjustedScopePosition(left, top) {
+        return [left - SCOPE_SIZE / 2, top - SCOPE_SIZE / 2];
+    }
+    static get delegatesFocus() { return true; }
+    static get assetsDirs() { return ["assets"]; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "alphaChannel": ["handleAlphaChannelChange", "handleFormatOrAlphaChannelChange"],
+        "color": ["handleColorChange"],
+        "format": ["handleFormatOrAlphaChannelChange"],
+        "scale": ["handleScaleChange"],
+        "messageOverrides": ["onMessagesChange"],
+        "value": ["handleValueChange"],
+        "effectiveLocale": ["effectiveLocaleChange"]
+    }; }
+};
+ColorPicker.style = colorPickerCss;
+
+export { ColorPicker as calcite_color_picker };