@spectrum-web-components/color-area 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@spectrum-web-components/color-area",
-    "version": "1.1.0",
+    "version": "1.1.2",
     "publishConfig": {
         "access": "public"
     },
@@ -63,11 +63,11 @@
     ],
     "dependencies": {
         "@ctrl/tinycolor": "^4.0.3",
-        "@spectrum-web-components/base": "^1.1.0",
-        "@spectrum-web-components/color-handle": "^1.1.0",
-        "@spectrum-web-components/opacity-checkerboard": "^1.1.0",
-        "@spectrum-web-components/reactive-controllers": "^1.1.0",
-        "@spectrum-web-components/shared": "^1.1.0"
+        "@spectrum-web-components/base": "^1.1.2",
+        "@spectrum-web-components/color-handle": "^1.1.2",
+        "@spectrum-web-components/opacity-checkerboard": "^1.1.2",
+        "@spectrum-web-components/reactive-controllers": "^1.1.2",
+        "@spectrum-web-components/shared": "^1.1.2"
     },
     "devDependencies": {
         "@spectrum-css/colorarea": "6.0.0-s2-foundations.15"
@@ -78,5 +78,5 @@
         "./sp-*.js",
         "./**/*.dev.js"
     ],
-    "gitHead": "e3c6e52501451acc6fa85b10dd718267b80a01ab"
+    "gitHead": "9ee45f2dfd3ac1939072726d00195c6c05d9a562"
 }

package/sp-color-area.d.ts

@@ -0,0 +1,6 @@
+import { ColorArea } from './src/ColorArea.js';
+declare global {
+    interface HTMLElementTagNameMap {
+        'sp-color-area': ColorArea;
+    }
+}

package/sp-color-area.dev.js

@@ -0,0 +1,5 @@
+"use strict";
+import { ColorArea } from "./src/ColorArea.dev.js";
+import { defineElement } from "@spectrum-web-components/base/src/define-element.js";
+defineElement("sp-color-area", ColorArea);
+//# sourceMappingURL=sp-color-area.dev.js.map

package/sp-color-area.dev.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["sp-color-area.ts"],
+  "sourcesContent": ["/*\nCopyright 2020 Adobe. All rights reserved.\nThis file is licensed to you under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License. You may obtain a copy\nof the License at http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software distributed under\nthe License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\nOF ANY KIND, either express or implied. See the License for the specific language\ngoverning permissions and limitations under the License.\n*/\n\nimport { ColorArea } from './src/ColorArea.dev.js'\nimport { defineElement } from '@spectrum-web-components/base/src/define-element.js';\n\ndefineElement('sp-color-area', ColorArea);\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'sp-color-area': ColorArea;\n    }\n}\n"],
+  "mappings": ";AAYA,SAAS,iBAAiB;AAC1B,SAAS,qBAAqB;AAE9B,cAAc,iBAAiB,SAAS;",
+  "names": []
+}

package/sp-color-area.js

@@ -0,0 +1,2 @@
+"use strict";import{ColorArea as e}from"./src/ColorArea.js";import{defineElement as r}from"@spectrum-web-components/base/src/define-element.js";r("sp-color-area",e);
+//# sourceMappingURL=sp-color-area.js.map

package/sp-color-area.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["sp-color-area.ts"],
+  "sourcesContent": ["/*\nCopyright 2020 Adobe. All rights reserved.\nThis file is licensed to you under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License. You may obtain a copy\nof the License at http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software distributed under\nthe License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\nOF ANY KIND, either express or implied. See the License for the specific language\ngoverning permissions and limitations under the License.\n*/\n\nimport { ColorArea } from './src/ColorArea.js';\nimport { defineElement } from '@spectrum-web-components/base/src/define-element.js';\n\ndefineElement('sp-color-area', ColorArea);\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'sp-color-area': ColorArea;\n    }\n}\n"],
+  "mappings": "aAYA,OAAS,aAAAA,MAAiB,qBAC1B,OAAS,iBAAAC,MAAqB,sDAE9BA,EAAc,gBAAiBD,CAAS",
+  "names": ["ColorArea", "defineElement"]
+}

package/src/ColorArea.d.ts

@@ -0,0 +1,65 @@
+import { CSSResultArray, PropertyValues, SpectrumElement, TemplateResult } from '@spectrum-web-components/base';
+import '@spectrum-web-components/color-handle/sp-color-handle.js';
+import { ColorValue } from '@spectrum-web-components/reactive-controllers/src/Color.js';
+/**
+ * @element sp-color-area
+ * @slot gradient - a custom gradient visually outlining the available color values
+ * @fires input - The value of the Color Area has changed.
+ * @fires change - An alteration to the value of the Color Area has been committed by the user.
+ */
+export declare class ColorArea extends SpectrumElement {
+    static get styles(): CSSResultArray;
+    dir: 'ltr' | 'rtl';
+    disabled: boolean;
+    focused: boolean;
+    labelX: string;
+    labelY: string;
+    private handle;
+    private languageResolver;
+    private colorController;
+    get hue(): number;
+    set hue(value: number);
+    get value(): ColorValue;
+    get color(): ColorValue;
+    set color(color: ColorValue);
+    private activeAxis;
+    get x(): number;
+    set x(x: number);
+    private _x;
+    get y(): number;
+    set y(y: number);
+    private _y;
+    step: number;
+    inputX: HTMLInputElement;
+    inputY: HTMLInputElement;
+    private altered;
+    private activeKeys;
+    private _valueChanged;
+    focus(focusOptions?: FocusOptions): void;
+    private forwardFocus;
+    private handleFocus;
+    handleBlur(): void;
+    private handleKeydown;
+    private handleKeypress;
+    private handleKeyup;
+    private handleInput;
+    private handleChange;
+    private boundingClientRect;
+    _pointerDown: boolean;
+    private handlePointerdown;
+    private handlePointermove;
+    private handlePointerup;
+    /**
+     * Returns the value under the cursor
+     * @param: PointerEvent on slider
+     * @return: Slider value that correlates to the position under the pointer
+     */
+    private calculateHandlePosition;
+    private handleAreaPointerdown;
+    protected render(): TemplateResult;
+    protected firstUpdated(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    private observer?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/src/ColorArea.dev.js

@@ -0,0 +1,507 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import {
+  html,
+  SpectrumElement
+} from "@spectrum-web-components/base";
+import {
+  ifDefined,
+  styleMap
+} from "@spectrum-web-components/base/src/directives.js";
+import {
+  property,
+  query
+} from "@spectrum-web-components/base/src/decorators.js";
+import { streamingListener } from "@spectrum-web-components/base/src/streaming-listener.js";
+import "@spectrum-web-components/color-handle/sp-color-handle.js";
+import {
+  ColorController
+} from "@spectrum-web-components/reactive-controllers/src/Color.js";
+import { LanguageResolutionController } from "@spectrum-web-components/reactive-controllers/src/LanguageResolution.js";
+import {
+  isAndroid,
+  isIOS
+} from "@spectrum-web-components/shared/src/platform.js";
+import styles from "./color-area.css.js";
+export class ColorArea extends SpectrumElement {
+  constructor() {
+    super(...arguments);
+    this.disabled = false;
+    this.focused = false;
+    this.labelX = "saturation";
+    this.labelY = "luminosity";
+    this.languageResolver = new LanguageResolutionController(this);
+    this.colorController = new ColorController(this, {
+      extractColorFromState: () => ({
+        h: this.hue,
+        s: this.x,
+        v: this.y
+      }),
+      applyColorToState: ({ s, v }) => {
+        this._x = s;
+        this._y = v;
+        this.requestUpdate();
+      }
+    });
+    this.activeAxis = "x";
+    this._x = 1;
+    this._y = 1;
+    this.step = 0.01;
+    this.altered = 0;
+    this.activeKeys = /* @__PURE__ */ new Set();
+    this._valueChanged = false;
+    this._pointerDown = false;
+  }
+  static get styles() {
+    return [styles];
+  }
+  get hue() {
+    return this.colorController.hue;
+  }
+  set hue(value) {
+    this.colorController.hue = value;
+  }
+  get value() {
+    return this.colorController.color;
+  }
+  get color() {
+    return this.colorController.color;
+  }
+  set color(color) {
+    this.colorController.color = color;
+  }
+  get x() {
+    return this._x;
+  }
+  set x(x) {
+    if (x === this.x) {
+      return;
+    }
+    const oldValue = this.x;
+    this._x = x;
+    if (this.inputX) {
+      this.inputX.value = x.toString();
+      this._x = this.inputX.valueAsNumber;
+    }
+    this.requestUpdate("x", oldValue);
+    this.colorController.applyColorFromState();
+  }
+  get y() {
+    return this._y;
+  }
+  set y(y) {
+    if (y === this.y) {
+      return;
+    }
+    const oldValue = this.y;
+    this._y = y;
+    if (this.inputY) {
+      this.inputY.value = y.toString();
+      this._y = this.inputY.valueAsNumber;
+    }
+    this.requestUpdate("y", oldValue);
+    this.colorController.applyColorFromState();
+  }
+  focus(focusOptions = {}) {
+    super.focus(focusOptions);
+    this.forwardFocus();
+  }
+  forwardFocus() {
+    this.focused = this.hasVisibleFocusInTree();
+    if (this.activeAxis === "x") {
+      this.inputX.focus();
+    } else {
+      this.inputY.focus();
+    }
+  }
+  handleFocus() {
+    this.focused = true;
+    this._valueChanged = false;
+  }
+  handleBlur() {
+    if (this._pointerDown) {
+      return;
+    }
+    this.altered = 0;
+    this.focused = false;
+    this._valueChanged = false;
+  }
+  handleKeydown(event) {
+    const { code } = event;
+    this.focused = true;
+    this.altered = [event.shiftKey, event.ctrlKey, event.altKey].filter(
+      (key) => !!key
+    ).length;
+    const isArrowKey = code.search("Arrow") === 0 || code.search("Page") === 0 || code.search("Home") === 0 || code.search("End") === 0;
+    if (isArrowKey) {
+      event.preventDefault();
+      this.activeKeys.add(code);
+      this.handleKeypress();
+    }
+  }
+  handleKeypress() {
+    let deltaX = 0;
+    let deltaY = 0;
+    const step = Math.max(this.step, this.altered * 5 * this.step);
+    this.activeKeys.forEach((code) => {
+      switch (code) {
+        case "ArrowUp":
+          deltaY = step;
+          break;
+        case "ArrowDown":
+          deltaY = step * -1;
+          break;
+        case "ArrowLeft":
+          deltaX = this.step * (this.isLTR ? -1 : 1);
+          break;
+        case "ArrowRight":
+          deltaX = this.step * (this.isLTR ? 1 : -1);
+          break;
+        case "PageUp":
+          deltaY = step * 10;
+          break;
+        case "PageDown":
+          deltaY = step * -10;
+          break;
+        case "Home":
+          deltaX = step * (this.isLTR ? -10 : 10);
+          break;
+        case "End":
+          deltaX = step * (this.isLTR ? 10 : -10);
+          break;
+        default:
+          break;
+      }
+    });
+    if (deltaX != 0) {
+      this.activeAxis = "x";
+      this.inputX.focus();
+    } else if (deltaY != 0) {
+      this.activeAxis = "y";
+      this.inputY.focus();
+    }
+    this.x = Math.min(1, Math.max(this.x + deltaX, 0));
+    this.y = Math.min(1, Math.max(this.y + deltaY, 0));
+    this.colorController.savePreviousColor();
+    this.colorController.applyColorFromState();
+    if (deltaX != 0 || deltaY != 0) {
+      this._valueChanged = true;
+      this.dispatchEvent(
+        new Event("input", {
+          bubbles: true,
+          composed: true
+        })
+      );
+      const applyDefault = this.dispatchEvent(
+        new Event("change", {
+          bubbles: true,
+          composed: true,
+          cancelable: true
+        })
+      );
+      if (!applyDefault) {
+        this.colorController.restorePreviousColor();
+      }
+    }
+  }
+  handleKeyup(event) {
+    event.preventDefault();
+    const { code } = event;
+    this.activeKeys.delete(code);
+  }
+  handleInput(event) {
+    const { valueAsNumber, name } = event.target;
+    this[name] = valueAsNumber;
+    this.colorController.applyColorFromState();
+  }
+  handleChange(event) {
+    this.handleInput(event);
+    this.dispatchEvent(
+      new Event("change", {
+        bubbles: true,
+        composed: true,
+        cancelable: true
+      })
+    );
+  }
+  handlePointerdown(event) {
+    if (event.button !== 0) {
+      event.preventDefault();
+      return;
+    }
+    this._pointerDown = true;
+    this.colorController.savePreviousColor();
+    this.boundingClientRect = this.getBoundingClientRect();
+    event.target.setPointerCapture(event.pointerId);
+    if (event.pointerType === "mouse") {
+      this.focused = true;
+    }
+  }
+  handlePointermove(event) {
+    const [x, y] = this.calculateHandlePosition(event);
+    this._valueChanged = false;
+    this.x = x;
+    this.y = 1 - y;
+    this.colorController.applyColorFromState();
+    this.dispatchEvent(
+      new Event("input", {
+        bubbles: true,
+        composed: true,
+        cancelable: true
+      })
+    );
+  }
+  handlePointerup(event) {
+    event.preventDefault();
+    this._pointerDown = false;
+    event.target.releasePointerCapture(event.pointerId);
+    const applyDefault = this.dispatchEvent(
+      new Event("change", {
+        bubbles: true,
+        composed: true,
+        cancelable: true
+      })
+    );
+    this.inputX.focus();
+    if (event.pointerType === "mouse") {
+      this.focused = false;
+    }
+    if (!applyDefault) {
+      this.colorController.restorePreviousColor();
+    }
+  }
+  /**
+   * Returns the value under the cursor
+   * @param: PointerEvent on slider
+   * @return: Slider value that correlates to the position under the pointer
+   */
+  calculateHandlePosition(event) {
+    if (!this.boundingClientRect) {
+      return [this.x, this.y];
+    }
+    const rect = this.boundingClientRect;
+    const minOffsetX = rect.left;
+    const minOffsetY = rect.top;
+    const offsetX = event.clientX;
+    const offsetY = event.clientY;
+    const width = rect.width;
+    const height = rect.height;
+    const percentX = Math.max(
+      0,
+      Math.min(1, (offsetX - minOffsetX) / width)
+    );
+    const percentY = Math.max(
+      0,
+      Math.min(1, (offsetY - minOffsetY) / height)
+    );
+    return [this.isLTR ? percentX : 1 - percentX, percentY];
+  }
+  handleAreaPointerdown(event) {
+    if (event.button !== 0) {
+      return;
+    }
+    event.stopPropagation();
+    event.preventDefault();
+    this.handle.dispatchEvent(new PointerEvent("pointerdown", event));
+    this.handlePointermove(event);
+  }
+  render() {
+    const { width = 0, height = 0 } = this.boundingClientRect || {};
+    const isMobile = isAndroid() || isIOS();
+    const defaultAriaLabel = "Color Picker";
+    const ariaLabel = defaultAriaLabel;
+    const ariaRoleDescription = ifDefined(
+      isMobile ? void 0 : "2d slider"
+    );
+    const ariaLabelX = this.labelX;
+    const ariaLabelY = this.labelY;
+    const ariaValueX = new Intl.NumberFormat(
+      this.languageResolver.language,
+      {
+        style: "percent",
+        unitDisplay: "narrow"
+      }
+    ).format(this.x);
+    const ariaValueY = new Intl.NumberFormat(
+      this.languageResolver.language,
+      {
+        style: "percent",
+        unitDisplay: "narrow"
+      }
+    ).format(this.y);
+    const style = {
+      background: `linear-gradient(to top, black 0%, hsla(${this.hue}, 100%, 0.01%, 0) 100%),linear-gradient(to right, white 0%, hsla(${this.hue}, 100%, 0.01%, 0) 100%), hsl(${this.hue}, 100%, 50%);`
+    };
+    return html`
+            <div
+                @pointerdown=${this.handleAreaPointerdown}
+                class="gradient"
+                style=${styleMap(style)}
+            >
+                <slot name="gradient"></slot>
+            </div>
+
+            <sp-color-handle
+                tabindex=${ifDefined(this.focused ? void 0 : "0")}
+                @focus=${this.forwardFocus}
+                ?focused=${this.focused}
+                class="handle"
+                color=${this.colorController.getHslString()}
+                ?disabled=${this.disabled}
+                style=${`transform: translate(${(this.isLTR ? this.x : 1 - this.x) * width}px, ${height - this.y * height}px);`}
+                ${streamingListener({
+      start: ["pointerdown", this.handlePointerdown],
+      streamInside: ["pointermove", this.handlePointermove],
+      end: [
+        ["pointerup", "pointercancel", "pointerleave"],
+        this.handlePointerup
+      ]
+    })}
+            ></sp-color-handle>
+
+            <fieldset
+                class="fieldset"
+                aria-label=${ifDefined(isMobile ? ariaLabel : void 0)}
+            >
+                <div role="presentation">
+                    <input
+                        type="range"
+                        class="slider"
+                        name="x"
+                        aria-label=${isMobile ? ariaLabelX : `${ariaLabelX} ${ariaLabel}`}
+                        aria-roledescription=${ariaRoleDescription}
+                        aria-orientation="horizontal"
+                        aria-valuetext=${isMobile ? ariaValueX : `${ariaValueX}, ${ariaLabelX}${this._valueChanged ? "" : `, ${ariaValueY}, ${ariaLabelY}`}`}
+                        min="0"
+                        max="1"
+                        step=${this.step}
+                        tabindex="-1"
+                        .value=${String(this.x)}
+                        @input=${this.handleInput}
+                        @change=${this.handleChange}
+                    />
+                </div>
+                <div role="presentation">
+                    <input
+                        type="range"
+                        class="slider"
+                        name="y"
+                        aria-label=${isMobile ? ariaLabelY : `${ariaLabelY} ${ariaLabel}`}
+                        aria-roledescription=${ariaRoleDescription}
+                        aria-orientation="vertical"
+                        aria-valuetext=${isMobile ? ariaValueY : `${ariaValueY}, ${ariaLabelY}${this._valueChanged ? "" : `, ${ariaValueX}, ${ariaLabelX}`}`}
+                        orient="vertical"
+                        min="0"
+                        max="1"
+                        step=${this.step}
+                        tabindex="-1"
+                        .value=${String(this.y)}
+                        @input=${this.handleInput}
+                        @change=${this.handleChange}
+                    />
+                </div>
+            </fieldset>
+        `;
+  }
+  firstUpdated(changed) {
+    super.firstUpdated(changed);
+    this.boundingClientRect = this.getBoundingClientRect();
+    this.addEventListener("focus", this.handleFocus);
+    this.addEventListener("blur", this.handleBlur);
+    this.addEventListener("keyup", this.handleKeyup);
+    this.addEventListener("keydown", this.handleKeydown);
+  }
+  updated(changed) {
+    super.updated(changed);
+    if (this.x !== this.inputX.valueAsNumber) {
+      this._x = this.inputX.valueAsNumber;
+    }
+    if (this.y !== this.inputY.valueAsNumber) {
+      this._y = this.inputY.valueAsNumber;
+    }
+    if (changed.has("focused") && this.focused) {
+      const parentX = this.inputX.parentElement;
+      const parentY = this.inputY.parentElement;
+      if (!parentX.shadowRoot && !parentY.shadowRoot) {
+        parentX.attachShadow({ mode: "open" });
+        parentY.attachShadow({ mode: "open" });
+        const slot = '<div tabindex="-1"><slot></slot></div>';
+        parentX.shadowRoot.innerHTML = slot;
+        parentY.shadowRoot.innerHTML = slot;
+      }
+    }
+  }
+  connectedCallback() {
+    var _a;
+    super.connectedCallback();
+    if (!this.observer && window.ResizeObserver) {
+      this.observer = new window.ResizeObserver((entries) => {
+        for (const entry of entries) {
+          this.boundingClientRect = entry.contentRect;
+        }
+        this.requestUpdate();
+      });
+    }
+    (_a = this.observer) == null ? void 0 : _a.observe(this);
+  }
+  disconnectedCallback() {
+    var _a;
+    (_a = this.observer) == null ? void 0 : _a.unobserve(this);
+    super.disconnectedCallback();
+  }
+}
+__decorateClass([
+  property({ type: String, reflect: true })
+], ColorArea.prototype, "dir", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], ColorArea.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], ColorArea.prototype, "focused", 2);
+__decorateClass([
+  property({ type: String, attribute: "label-x" })
+], ColorArea.prototype, "labelX", 2);
+__decorateClass([
+  property({ type: String, attribute: "label-y" })
+], ColorArea.prototype, "labelY", 2);
+__decorateClass([
+  query(".handle")
+], ColorArea.prototype, "handle", 2);
+__decorateClass([
+  property({ type: Number })
+], ColorArea.prototype, "hue", 1);
+__decorateClass([
+  property({ type: String })
+], ColorArea.prototype, "value", 1);
+__decorateClass([
+  property({ type: String })
+], ColorArea.prototype, "color", 1);
+__decorateClass([
+  property({ attribute: false })
+], ColorArea.prototype, "activeAxis", 2);
+__decorateClass([
+  property({ type: Number })
+], ColorArea.prototype, "x", 1);
+__decorateClass([
+  property({ type: Number })
+], ColorArea.prototype, "y", 1);
+__decorateClass([
+  property({ type: Number })
+], ColorArea.prototype, "step", 2);
+__decorateClass([
+  query('[name="x"]')
+], ColorArea.prototype, "inputX", 2);
+__decorateClass([
+  query('[name="y"]')
+], ColorArea.prototype, "inputY", 2);
+//# sourceMappingURL=ColorArea.dev.js.map