color-elements 0.0.2 → 0.0.3

package/src/channel-picker/channel-picker.js

@@ -0,0 +1,168 @@
+import ColorElement from "../common/color-element.js";
+import "../space-picker/space-picker.js";
+import * as dom from "../common/dom.js";
+
+const Self = class ChannelPicker extends ColorElement {
+	static tagName = "channel-picker";
+	static url = import.meta.url;
+	static shadowStyle = true;
+	static shadowTemplate = `
+		<space-picker part="color-space" exportparts="base: color-space-base" id="space_picker"></space-picker>
+		<select id="picker" part="color-channel-base"></select>`;
+
+	constructor () {
+		super();
+
+		this._el = dom.named(this);
+
+		// We need to start listening for this event as soon as the <space-picker> is created
+		this._el.space_picker.addEventListener("spacechange", this);
+
+		// We need to render the picker as soon as possible so as not to choke on invalid initial values
+		this.#render();
+	}
+
+	connectedCallback () {
+		super.connectedCallback?.();
+
+		this._el.picker.addEventListener("input", this);
+	}
+
+	disconnectedCallback () {
+		super.disconnectedCallback?.();
+
+		this._el.space_picker.removeEventListener("spacechange", this);
+		this._el.picker.removeEventListener("input", this);
+	}
+
+	get selectedSpace () {
+		return this._el.space_picker.selectedSpace;
+	}
+
+	get selectedChannel () {
+		return this.selectedSpace.coords?.[this._el.picker.value];
+	}
+
+	/**
+	 * Previously selected channels for each space.
+	 * Keys are space IDs. Values are coords.
+	 */
+	#history = {};
+
+	#render () {
+		let space = this.selectedSpace;
+		let coords = space.coords;
+
+		if (space && !coords) {
+			console.warn(`Color space "${ space.name }" has no coordinates.`);
+			return;
+		}
+
+		this._el.picker.innerHTML = Object.entries(coords)
+			.map(([id, coord]) => `<option value="${ id }">${ coord.name }</option>`)
+			.join("\n");
+
+		let [prevSpace, prevChannel] = this.value?.split(".") ?? [];
+		if (prevSpace && prevChannel) {
+			let prevChannelName = this._el.space_picker.spaces[prevSpace].coords[prevChannel].name;
+			let currentChannelName = coords[prevChannel]?.name;
+			if (prevChannelName === currentChannelName) {
+				// Preserve the channel if it exists in the new space and has the same name ("b" in "oklab" is not the same as "b" in "p3")
+				this._el.picker.value = prevChannel;
+			}
+			else if (this.#history?.[space.id]) {
+				// Otherwise, try to restore the last channel used
+				this._el.picker.value = this.#history[space.id];
+			}
+		}
+	}
+
+	handleEvent (event) {
+		if (event.type === "spacechange") {
+			this.#render();
+		}
+
+		if ([this._el.space_picker, this._el.picker].includes(event.target)) {
+			let value = `${ this._el.space_picker.value }.${ this._el.picker.value }`;
+			if (value !== this.value) {
+				this.value = value;
+			}
+		}
+	}
+
+	propChangedCallback ({name, prop, detail: change}) {
+		if (name === "value" && this.value) {
+			let [space, channel] = (this.value + "").split(".");
+
+			let currentSpace = this._el.space_picker.value;
+			let currentCoord = this._el.picker.value;
+			let currentValue = `${ currentSpace }.${ currentCoord }`;
+
+			if (!space || !channel) {
+				console.warn(`Invalid value "${ this.value }". Expected format: "space.channel". Falling back to "${ currentValue }".`);
+				this.value = currentValue;
+			}
+			else {
+				let spaces = Object.keys(this._el.space_picker.spaces);
+
+				if (!spaces.includes(space)) {
+					console.warn(`No "${ space }" color space found. Choose one of the following: ${ spaces.join(", ") }. Falling back to "${ currentSpace }".`);
+					this.value = currentValue;
+				}
+				else {
+					if (currentSpace !== space) {
+						this._el.space_picker.value = space;
+					}
+
+					if (currentCoord && currentCoord !== channel) {
+						let coords = Object.keys(this.selectedSpace.coords ?? {});
+
+						if (coords.includes(channel)) {
+							this._el.picker.value = channel;
+						}
+						else {
+							currentCoord = coords.includes(currentCoord) ? currentCoord : coords[0];
+
+							let message = `Color space "${ space }" has no coordinate "${ channel }".`;
+							if (coords.length) {
+								message += ` Choose one of the following: ${ coords.join(", ") }.`;
+							}
+							message += ` Falling back to "${ currentCoord }".`;
+							console.warn(message);
+							this.value = `${ space }.${ currentCoord }`;
+							channel = currentCoord;
+						}
+					}
+
+					this.#history[space] = channel;
+				}
+			}
+		}
+	}
+
+	static props = {
+		value: {
+			default: "oklch.l",
+		},
+	};
+
+	static events = {
+		change: {
+			from () {
+				return [this._el.space_picker, this._el.picker];
+			},
+		},
+		input: {
+			from () {
+				return [this._el.space_picker, this._el.picker];
+			},
+		},
+		valuechange: {
+			propchange: "value",
+		},
+	};
+};
+
+Self.define();
+
+export default Self;

package/src/channel-slider/README.md

@@ -6,8 +6,8 @@ A [`<color-slider>`](../color-slider) for a specific channel, intended for color
 
 This is a higher level component than `<color-slider>` for the cases where you want to control a single channel of a color space.
 It offers many conveniences for these cases:
-- It takes care of applying the right `min` and `max` values to the slider
-- It automatically generates the start and end colors,
+- It takes care of applying the right `min`, `max`, and `step` values to the slider
+- It automatically generates the start and end colors
 - It can provide an editable tooltip as a tooltip that both shows and edits the current value
 - Already includes a suitable label
 
@@ -19,6 +19,12 @@ Basic example:
 <channel-slider space="oklch" channel="h"></channel-slider>
 ```
 
+The alpha channel is also supported:
+
+```html
+<channel-slider space="oklch" channel="alpha"></channel-slider>
+```
+
 In most cases you’d also want to set a color to set the other channels and the initial value:
 
 ```html
@@ -81,6 +87,7 @@ All attributes are reactive:
 		<option>l</option>
 		<option>c</option>
 		<option>h</option>
+		<option>alpha</option>
 	</select>
 </label>
 
@@ -90,13 +97,13 @@ All attributes are reactive:
 <script>
 	function fromSlider () {
 		space_select.value = dynamic_slider.space.id;
-		channel_select.innerHTML = Object.keys(dynamic_slider.space.coords).map(c => `<option>${c}</option>`).join('\n');
-		channel_select.value = dynamic_slider.channel;
+		channel_select.innerHTML = [...Object.keys(dynamic_slider.space.coords).map(c => `<option>${c}</option>`), "<option>alpha</option>"].join('\n');
+		channel_select.value = dynamic_slider.channel || channel_select.options[0].value;
 	}
 
 	function fromSelects () {
 		dynamic_slider.space = space_select.value;
-		dynamic_slider.channel = channel_select.value;
+		dynamic_slider.channel = channel_select.value || channel_select.options[0].value;
 	}
 
 	space_select.oninput = channel_select.oninput = fromSelects;
@@ -109,6 +116,12 @@ All attributes are reactive:
 
 ## Reference
 
+### Slots
+
+| Name | Description |
+|------|-------------|
+| _(default)_ | The channel slider's label. |
+
 ### Attributes & Properties
 
 | Attribute | Property | Property type | Default value | Description |
@@ -117,7 +130,36 @@ All attributes are reactive:
 | `channel` | `channel` | `string` | `h` | The component to use for the gradient. |
 | `min` | `min` | `number` | `this.refRange[0]` | The minimum value for the slider. |
 | `max` | `max` | `number` | `this.refRange[1]` | The maximum value for the slider. |
+| `step` | `step` | `number` | Computed automatically based on `this.min` and `this.max`. | The granularity that the slider's current value must adhere to. |
 | `value` | `value` | `number` | `(this.min + this.max) / 2` | The current value of the slider. |
-| `color` | `color` | `Color` &#124; `string` | `oklch(50 50% 180)` | The current color value. |
-| - | `minColor` | `Color` | `oklch(0 50% 180)` | The minimum color value _(read-only)_. |
-| - | `maxColor` | `Color` | `oklch(100 50% 180)` | The maximum color value _(read-only)_. |
+| `color` | `color` | `Color` &#124; `string` | `oklch(50% 50% 180)` | The current color value. |
+
+### Getters
+
+These properties are read-only.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `minColor` | `Color` | The color corresponding to the minimum value of the slider. |
+| `maxColor` | `Color` | The color corresponding to the maximum value of the slider. |
+| `stops` | `Array<Color>` | The array of the slider color stops used for rendering. Unsupported color spaces or angular channels (hues) will have more color stops, while other channels may have as little as two: `minColor` and `maxColor`. |
+| `progress` | `number` | The slider value converted to a 0-1 number with `0` corresponding to the min of the range and `1` to the max. |
+| `channelName` | `string` | The name of the channel (e.g. `Hue` or `Alpha`). |
+
+
+### Events
+
+| Name | Description |
+|------|-------------|
+| `input` | Fired when the color changes due to user action. |
+| `change` | Fired when the color changes due to user action. |
+| `valuechange` | Fired when the value changes for any reason, and once during initialization. |
+| `colorchange` | Fired when the color changes for any reason, and once during initialization. |
+
+### Parts
+
+| Name | Description |
+|------|-------------|
+| `color_slider` | The internal `<color-slider>` element. |
+| `slider` | The `slider` part of the internal [`<color-slider>`](../color-slider/#parts) element. |
+| `label` | The internal `<label>` element used as a wrapper around the default slot and the slider. |

package/src/channel-slider/channel-slider.css

@@ -1,19 +1,61 @@
 .color-slider-label {
+	--_transition-duration: var(--transition-duration, 200ms);
+
 	display: grid;
 	grid-template-columns: 1fr auto;
 	gap: .3em;
-	position: relative;
+	align-items: center;
 
 	em {
 		opacity: 60%;
+		transition: opacity var(--_transition-duration);
 	}
-}
 
-color-slider {
-	grid-column: 1 / -1;
-}
+	&:not(:hover, :focus-within) em {
+		opacity: 0;
+	}
+
+	input[type=number] {
+		--_border-color: var(--border-color, color-mix(in oklab, currentcolor calc(var(--_current-color-percent, 30) * 1%), oklab(none none none / 0%)));
+
+		all: unset;
 
+		--content-width: calc(var(--value-length) * 1ch);
+		width: calc(var(--content-width, 2ch) + 1.2em);
+		min-width: calc(2ch + 1.2em);
+		box-sizing: content-box;
+		padding: .1em .2em;
+		border-radius: .2em;
+		border: 1px solid var(--_border-color);
+		text-align: center;
+		font-size: 90%;
+		transition: var(--_transition-duration) allow-discrete;
+		transition-property: opacity, border-color;
 
+		&::-webkit-textfield-decoration-container {
+			gap: .2em;
+		}
 
+		&:not(:hover, :focus) {
+			--_current-color-percent: 10;
 
+			opacity: 60%;
+			border-color: var(--_border-color);
 
+			&::-webkit-inner-spin-button {
+				/* Fade out the spin buttons in Chrome and Safari */
+				opacity: .35;
+				filter: contrast(2);
+			}
+		}
+
+		@supports (field-sizing: content) {
+			field-sizing: content;
+			width: auto;
+		}
+	}
+}
+
+color-slider {
+	grid-column: 1 / -1;
+}

package/src/channel-slider/channel-slider.js

@@ -1,40 +1,41 @@
 import "../color-slider/color-slider.js";
 import * as dom from "../common/dom.js";
-import Color from "../common/color.js";
-import NudeElement from "../../node_modules/nude-element/src/Element.js";
+import ColorElement from "../common/color-element.js";
 import { getStep } from "../common/util.js";
 
-export const tagName = "channel-slider";
+const Self = class ChannelSlider extends ColorElement {
+	static tagName = "channel-slider";
+	static url = import.meta.url;
+	static shadowStyle = true;
+	static shadowTemplate = `
+		<label class="color-slider-label" part="label">
+			<slot>
+				<span id="channel_info" part="channel-info"></span>
+				<input type="number" part="spinner" min="0" max="1" step="0.01" id="spinner" />
+			</slot>
+			<color-slider part="color_slider" exportparts="slider" id="slider"></color-slider>
+		</label>`;
 
-export default class ChannelSlider extends NudeElement {
 	constructor () {
 		super();
 
-		this.attachShadow({mode: "open"});
-		let styleURL = new URL(`./${tagName}.css`, import.meta.url);
-		this.shadowRoot.innerHTML = `
-			<style>@import url("${ styleURL }")</style>
-			<label class="color-slider-label" part="label">
-				<slot></slot>
-				<color-slider part="color_slider" exportparts="slider" id="slider" tooltip></color-slider>
-			</label>
-		`;
-
 		this._el = dom.named(this);
 		this._el.slot = this.shadowRoot.querySelector("slot");
 	}
 
-	connectedCallback() {
+	connectedCallback () {
 		super.connectedCallback?.();
 
 		this._el.slider.addEventListener("input", this);
+		this._el.slot.addEventListener("input", this);
 	}
 
-	disconnectedCallback() {
+	disconnectedCallback () {
 		this._el.slider.removeEventListener("input", this);
+		this._el.slot.removeEventListener("input", this);
 	}
 
-	handleEvent(event) {
+	handleEvent (event) {
 		if (event.type === "input") {
 			this.value = event.target.value;
 		}
@@ -42,12 +43,14 @@ export default class ChannelSlider extends NudeElement {
 
 	colorAt (value) {
 		let color = this.defaultColor.clone();
-		try {
-			color.set(this.channel, value);
+
+		if (this.channel === "alpha") {
+			color.alpha = value / 100;
 		}
-		catch (e) {
-			console.warn(e);
+		else if (this.channel in color.space.coords) {
+			color.set(this.channel, value);
 		}
+
 		return color;
 	}
 
@@ -86,19 +89,30 @@ export default class ChannelSlider extends NudeElement {
 	propChangedCallback ({name, prop, detail: change}) {
 		if (["space", "min", "max", "step", "value", "defaultValue"].includes(name)) {
 			prop.applyChange(this._el.slider, change);
-		};
+
+			if (["min", "max", "step", "value", "defaultValue"].includes(name)) {
+				prop.applyChange(this._el.spinner, change);
+
+				if (name === "value" && this.value !== undefined) {
+					this._el.spinner.value = Number(this.value.toPrecision(4));
+
+					if (!CSS.supports("field-sizing", "content")) {
+						let valueStr = this._el.spinner.value;
+						this._el.spinner.style.setProperty("--value-length", valueStr.length);
+					}
+				}
+			}
+		}
 
 		if (name === "defaultColor" || name === "space" || name === "channel" || name === "min" || name === "max") {
 			this._el.slider.stops = this.stops;
 
 			if (name === "space" || name === "channel" || name === "min" || name === "max") {
-				this._el.slot.innerHTML = `${ this.channelName } <em>(${ this.min }&thinsp;&ndash;&thinsp;${ this.max })</em>`;
+				this._el.channel_info.innerHTML = `${ this.channelName } <em>(${ this.min }&thinsp;&ndash;&thinsp;${ this.max })</em>`;
 			}
 		}
 	}
 
-
-
 	get channelName () {
 		return this.channelSpec?.name ?? this.channel;
 	}
@@ -107,13 +121,13 @@ export default class ChannelSlider extends NudeElement {
 		space: {
 			default: "oklch",
 			parse (value) {
-				if (value instanceof Color.Space || value === null || value === undefined) {
+				if (value instanceof Self.Color.Space || value === null || value === undefined) {
 					return value;
 				}
 
 				value += "";
 
-				return Color.Space.get(value);
+				return Self.Color.Space.get(value);
 			},
 			stringify (value) {
 				return value?.id;
@@ -140,6 +154,12 @@ export default class ChannelSlider extends NudeElement {
 		},
 		channelSpec: {
 			get () {
+				if (this.channel === "alpha") {
+					return {
+						name: "Alpha",
+					};
+				}
+
 				let channelSpec = this.space?.coords[this.channel];
 
 				if (!channelSpec && this.space) {
@@ -148,7 +168,7 @@ export default class ChannelSlider extends NudeElement {
 				}
 
 				return channelSpec;
-			}
+			},
 		},
 		refRange: {
 			get () {
@@ -178,7 +198,16 @@ export default class ChannelSlider extends NudeElement {
 		defaultValue: {
 			type: Number,
 			default () {
-				return this.defaultColor.get(this.channel);
+				if (this.channel === "alpha") {
+					return this.defaultColor.alpha * 100;
+				}
+				else if (this.channel in this.defaultColor.space.coords) {
+					return this.defaultColor.get(this.channel);
+				}
+				else {
+					let firstChannel = Object.keys(this.defaultColor.space.coords)[0];
+					return this.defaultColor.get(firstChannel);
+				}
 			},
 			reflect: {
 				from: "value",
@@ -191,7 +220,9 @@ export default class ChannelSlider extends NudeElement {
 		},
 
 		defaultColor: {
-			type: Color,
+			get type () {
+				return Self.Color;
+			},
 			convert (color) {
 				return color.to(this.space);
 			},
@@ -199,18 +230,20 @@ export default class ChannelSlider extends NudeElement {
 				let coords = [];
 				for (let channel in this.space.coords) {
 					let spec = this.space.coords[channel];
-					let range = spec.refRange ?? spec.range;
+					let range = spec.refRange ?? spec.range ?? [0, 100];
 					coords.push((range[0] + range[1]) / 2);
 				}
 
-				return new Color(this.space, coords);
+				return new Self.Color(this.space, coords);
 			},
 			reflect: {
 				from: "color",
 			},
 		},
 		color: {
-			type: Color,
+			get type () {
+				return Self.Color;
+			},
 			get () {
 				return this.colorAt(this.value);
 			},
@@ -220,18 +253,18 @@ export default class ChannelSlider extends NudeElement {
 				this.value = this.defaultValue;
 			},
 		},
-	}
+	};
 
 	static events = {
 		change: {
 			from () {
 				return this._el.slider;
-			}
+			},
 		},
 		input: {
 			from () {
 				return this._el.slider;
-			}
+			},
 		},
 		valuechange: {
 			propchange: "value",
@@ -242,11 +275,13 @@ export default class ChannelSlider extends NudeElement {
 	};
 
 	static formAssociated = {
-		getSource: el => el._el.slider,
+		like: el => el._el.slider,
 		role: "slider",
 		valueProp: "value",
 		changeEvent: "valuechange",
 	};
-}
+};
+
+Self.define();
 
-customElements.define(tagName, ChannelSlider);
+export default Self;