@infinite-canvas-tutorial/webcomponents/esm/spectrum/color-picker.js

WebComponents UI implementation

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
import { css, html, LitElement } from 'lit';
import { customElement, property, state } from 'lit/decorators.js';
import { when } from 'lit/directives/when.js';
import { isGradient } from '@infinite-canvas-tutorial/ecs';
export var ColorType;
(function (ColorType) {
    ColorType["None"] = "none";
    ColorType["Solid"] = "solid";
    ColorType["Gradient"] = "gradient";
})(ColorType || (ColorType = {}));
let ColorPicker = class ColorPicker extends LitElement {
    constructor() {
        super(...arguments);
        this.types = [ColorType.None, ColorType.Solid, ColorType.Gradient];
        this.type = ColorType.None;
        this.prevColors = {
            [ColorType.None]: 'none',
            [ColorType.Solid]: '#000',
            [ColorType.Gradient]: 'linear-gradient(to right, #000, #fff)',
        };
    }
    willUpdate(changedProperties) {
        if (changedProperties.has('value')) {
            this.type =
                !this.value || this.value === 'none'
                    ? ColorType.None
                    : isGradient(this.value)
                        ? ColorType.Gradient
                        : ColorType.Solid;
            this.prevColors[this.type] = this.value;
        }
    }
    handleTypeChanged(e) {
        const type = e.target.selected[0];
        this.dispatchEvent(new CustomEvent('color-change', {
            detail: {
                type,
                value: this.prevColors[type],
            },
            bubbles: true,
            composed: true,
        }));
    }
    handleColorChanged(e) {
        const { type, value } = e.detail;
        this.prevColors[type] = value;
    }
    render() {
        return html `
      <h4>Select a color</h4>
      ${when(this.types.length > 1, () => html `<sp-action-group
          quiet
          compact
          size="m"
          selects="single"
          .selected=${[this.type]}
          @change=${this.handleTypeChanged}
        >
          ${when(this.types.includes(ColorType.None), () => html `
              <sp-action-button value=${ColorType.None}>
                <sp-tooltip self-managed placement="bottom">
                  No color
                </sp-tooltip>
                <sp-swatch nothing slot="icon"> </sp-swatch>
              </sp-action-button>
            `)}
          ${when(this.types.includes(ColorType.Solid), () => html `
              <sp-action-button value=${ColorType.Solid}>
                <sp-tooltip self-managed placement="bottom"> Solid </sp-tooltip>
                <sp-swatch
                  color=${this.prevColors[ColorType.Solid]}
                  slot="icon"
                >
                </sp-swatch>
              </sp-action-button>
            `)}
          ${when(this.types.includes(ColorType.Gradient), () => html `
              <sp-action-button value=${ColorType.Gradient}>
                <sp-tooltip self-managed placement="bottom">
                  Gradient
                </sp-tooltip>
                <sp-swatch
                  style="transform: rotate(90deg);"
                  color=${this.prevColors[ColorType.Gradient]}
                  slot="icon"
                >
                </sp-swatch>
              </sp-action-button>
            `)}
        </sp-action-group>`)}
      ${when(this.type === ColorType.Solid, () => html `
          <ic-spectrum-input-solid
            value=${this.prevColors[ColorType.Solid]}
            @color-change=${this.handleColorChanged}
          ></ic-spectrum-input-solid>
        `)}
      ${when(this.type === ColorType.Gradient, () => html `<ic-spectrum-input-gradient
          value=${this.prevColors[ColorType.Gradient]}
          @color-change=${this.handleColorChanged}
        ></ic-spectrum-input-gradient>`)}
    `;
    }
};
ColorPicker.styles = css `
    :host {
      display: flex;
      flex-direction: column;
      gap: 8px;
      padding: 8px;
      height: 200px;
    }

    h4 {
      margin: 0;
    }
  `;
__decorate([
    property()
], ColorPicker.prototype, "value", void 0);
__decorate([
    property()
], ColorPicker.prototype, "types", void 0);
__decorate([
    state()
], ColorPicker.prototype, "type", void 0);
__decorate([
    state()
], ColorPicker.prototype, "prevColors", void 0);
ColorPicker = __decorate([
    customElement('ic-spectrum-color-picker')
], ColorPicker);
export { ColorPicker };
//# sourceMappingURL=color-picker.js.map