color-elements 0.0.2 → 0.0.4

package/lib/colorjs.io/colorjs.io/src/display.js

@@ -1,83 +0,0 @@
-import { isNone, skipNone } from "./util.js";
-import defaults from "./defaults.js";
-import to from "./to.js";
-import serialize from "./serialize.js";
-import clone from "./clone.js";
-import REC2020 from "./spaces/rec2020.js";
-import P3 from "./spaces/p3.js";
-import Lab from "./spaces/lab.js";
-import sRGB from "./spaces/srgb.js";
-
-// Default space for CSS output. Code in Color.js makes this wider if there's a DOM available
-defaults.display_space = sRGB;
-
-let supportsNone;
-
-if (typeof CSS !== "undefined" && CSS.supports) {
-	// Find widest supported color space for CSS
-	for (let space of [Lab, REC2020, P3]) {
-		let coords = space.getMinCoords();
-		let color = {space, coords, alpha: 1};
-		let str = serialize(color);
-
-		if (CSS.supports("color", str)) {
-			defaults.display_space = space;
-			break;
-		}
-	}
-}
-
-/**
- * Returns a serialization of the color that can actually be displayed in the browser.
- * If the default serialization can be displayed, it is returned.
- * Otherwise, the color is converted to Lab, REC2020, or P3, whichever is the widest supported.
- * In Node.js, this is basically equivalent to `serialize()` but returns a `String` object instead.
- *
- * @export
- * @param {{space, coords} | Color | string} color
- * @param {*} [options={}] Options to be passed to serialize()
- * @param {ColorSpace | string} [options.space = defaults.display_space] Color space to use for serialization if default is not supported
- * @returns {String} String object containing the serialized color with a color property containing the converted color (or the original, if no conversion was necessary)
- */
-export default function display (color, {space = defaults.display_space, ...options} = {}) {
-	let ret = serialize(color, options);
-
-	if (typeof CSS === "undefined" || CSS.supports("color", ret) || !defaults.display_space) {
-		ret = new String(ret);
-		ret.color = color;
-	}
-	else {
-		// If we're here, what we were about to output is not supported
-		let fallbackColor = color;
-
-		// First, check if the culprit is none values
-		let hasNone = color.coords.some(isNone) || isNone(color.alpha);
-
-		if (hasNone) {
-			// Does the browser support none values?
-			if (!(supportsNone ??= CSS.supports("color", "hsl(none 50% 50%)"))) {
-				// Nope, try again without none
-				fallbackColor = clone(color);
-				fallbackColor.coords = fallbackColor.coords.map(skipNone);
-				fallbackColor.alpha = skipNone(fallbackColor.alpha);
-
-				ret = serialize(fallbackColor, options);
-
-				if (CSS.supports("color", ret)) {
-					// We're done, now it's supported
-					ret = new String(ret);
-					ret.color = fallbackColor;
-					return ret;
-				}
-			}
-		}
-
-		// If we're here, the color function is not supported
-		// Fall back to fallback space
-		fallbackColor = to(fallbackColor, space);
-		ret = new String(serialize(fallbackColor, options));
-		ret.color = fallbackColor;
-	}
-
-	return ret;
-}

package/lib/colorjs.io/colorjs.io/src/distance.js

@@ -1,21 +0,0 @@
-import ColorSpace from "./space.js";
-
-/**
- * Euclidean distance of colors in an arbitrary color space
- */
-export default function distance (color1, color2, space = "lab") {
-	space = ColorSpace.get(space);
-
-	// Assume getColor() is called on color in space.from()
-	let coords1 = space.from(color1);
-	let coords2 = space.from(color2);
-
-	return Math.sqrt(coords1.reduce((acc, c1, i) => {
-		let c2 = coords2[i];
-		if (isNaN(c1) || isNaN(c2)) {
-			return acc;
-		}
-
-		return acc + (c2 - c1) ** 2;
-	}, 0));
-}

package/lib/colorjs.io/colorjs.io/src/equals.js

@@ -1,10 +0,0 @@
-import getColor from "./getColor.js";
-
-export default function equals (color1, color2) {
-	color1 = getColor(color1);
-	color2 = getColor(color2);
-
-	return color1.space === color2.space
-	       && color1.alpha === color2.alpha
-	       && color1.coords.every((c, i) => c === color2.coords[i]);
-}

package/lib/colorjs.io/colorjs.io/src/get.js

@@ -1,11 +0,0 @@
-import ColorSpace from "./space.js";
-import getAll from "./getAll.js";
-import getColor from "./getColor.js";
-
-export default function get (color, prop) {
-	color = getColor(color);
-
-	let {space, index} = ColorSpace.resolveCoord(prop, color.space);
-	let coords = getAll(color, space);
-	return coords[index];
-}

package/lib/colorjs.io/colorjs.io/src/getAll.js

@@ -1,20 +0,0 @@
-import ColorSpace from "./space.js";
-import getColor from "./getColor.js";
-
-/**
- * Get the coordinates of a color in any color space
- * @param {Color} color
- * @param {string | ColorSpace} [space = color.space] The color space to convert to. Defaults to the color's current space
- * @returns {number[]} The color coordinates in the given color space
- */
-export default function getAll (color, space) {
-	color = getColor(color);
-
-	if (!space || color.space.equals(space)) {
-		// No conversion needed
-		return color.coords.slice();
-	}
-
-	space = ColorSpace.get(space);
-	return space.from(color);
-}

package/lib/colorjs.io/colorjs.io/src/getColor.js

@@ -1,36 +0,0 @@
-import ColorSpace from "./space.js";
-import {isString} from "./util.js";
-import parse from "./parse.js";
-
-/**
- * Resolves a color reference (object or string) to a plain color object
- * @param {Color | {space, coords, alpha} | string | Array<Color | {space, coords, alpha} | string> } color
- * @returns {{space, coords, alpha} | Array<{space, coords, alpha}}>
- */
-export default function getColor (color) {
-	if (Array.isArray(color)) {
-		return color.map(getColor);
-	}
-
-	if (!color) {
-		throw new TypeError("Empty color reference");
-	}
-
-	if (isString(color)) {
-		color = parse(color);
-	}
-
-	// Object fixup
-	let space = color.space || color.spaceId;
-
-	if (!(space instanceof ColorSpace)) {
-		// Convert string id to color space object
-		color.space = ColorSpace.get(space);
-	}
-
-	if (color.alpha === undefined) {
-		color.alpha = 1;
-	}
-
-	return color;
-}

package/lib/colorjs.io/colorjs.io/src/hooks.js

@@ -1,37 +0,0 @@
-/**
- * A class for adding deep extensibility to any piece of JS code
- */
-export class Hooks {
-	add (name, callback, first) {
-		if (typeof arguments[0] != "string") {
-			// Multiple hooks
-			for (var name in arguments[0]) {
-				this.add(name, arguments[0][name], arguments[1]);
-			}
-
-			return;
-		}
-
-		(Array.isArray(name) ? name : [name]).forEach(function (name) {
-			this[name] = this[name] || [];
-
-			if (callback) {
-				this[name][first ? "unshift" : "push"](callback);
-			}
-		}, this);
-	}
-
-	run (name, env) {
-		this[name] = this[name] || [];
-		this[name].forEach(function (callback) {
-			callback.call(env && env.context ? env.context : env, env);
-		});
-	}
-}
-
-/**
- * The instance of {@link Hooks} used throughout Color.js
- */
-const hooks = new Hooks();
-
-export default hooks;

package/lib/colorjs.io/colorjs.io/src/inGamut.js

@@ -1,25 +0,0 @@
-import ColorSpace from "./space.js";
-import getColor from "./getColor.js";
-
-const ε = .000075;
-
-/**
- * Check if a color is in gamut of either its own or another color space
- * @return {Boolean} Is the color in gamut?
- */
-export default function inGamut (color, space, {epsilon = ε} = {}) {
-	color = getColor(color);
-
-	if (!space) {
-		space = color.space;
-	}
-
-	space = ColorSpace.get(space);
-	let coords = color.coords;
-
-	if (space !== color.space) {
-		coords = space.from(color);
-	}
-
-	return space.inGamut(coords, {epsilon});
-}

package/lib/colorjs.io/colorjs.io/src/index-fn.js

@@ -1,28 +0,0 @@
-export {default as ColorSpace}          from "./space.js";
-export {default as RGBColorSpace}       from "./rgbspace.js";
-export {default as hooks, Hooks}        from "./hooks.js";
-export {default as defaults}            from "./defaults.js";
-export {default as getColor}            from "./getColor.js";
-export {default as get}                 from "./get.js";
-export {default as getAll}              from "./getAll.js";
-export {default as set}                 from "./set.js";
-export {default as setAll}              from "./setAll.js";
-export {default as parse}               from "./parse.js";
-export {default as to}                  from "./to.js";
-export {default as serialize}           from "./serialize.js";
-export {default as display}             from "./display.js";
-export {default as inGamut}             from "./inGamut.js";
-export {default as toGamut, toGamutCSS} from "./toGamut.js";
-export {default as distance}            from "./distance.js";
-export {default as equals}              from "./equals.js";
-export {default as contrast}            from "./contrast.js";
-export {default as clone}               from "./clone.js";
-export { getLuminance, setLuminance }   from "./luminance.js";
-export {uv, xy}                         from "./chromaticity.js";
-export *                                from "./contrast/index.js";
-export {default as deltaE}              from "./deltaE.js";
-export *                                from "./deltaE/index.js";
-export {default as deltaEMethods}       from "./deltaE/index.js";
-export *                                from "./variations.js";
-export { mix, steps, range, isRange }   from "./interpolation.js";
-export *                                from "./spaces/index-fn.js";

package/lib/colorjs.io/colorjs.io/src/index.js

@@ -1,38 +0,0 @@
-// Import all modules of Color.js
-import Color from "./color.js";
-
-// Import all color spaces
-import "./spaces/index.js";
-
-// Import all DeltaE methods
-import deltaE from "./deltaE.js";
-import deltaEMethods from "./deltaE/index.js";
-
-Color.extend(deltaEMethods);
-Color.extend({deltaE});
-Object.assign(Color, {deltaEMethods});
-
-// Import optional modules
-import * as variations from "./variations.js";
-Color.extend(variations);
-
-import contrast from "./contrast.js";
-Color.extend({contrast});
-
-import * as chromaticity from "./chromaticity.js";
-Color.extend(chromaticity);
-
-import * as luminance from "./luminance.js";
-Color.extend(luminance);
-
-import * as interpolation from "./interpolation.js";
-Color.extend(interpolation);
-
-import * as contrastMethods from "./contrast/index.js";
-Color.extend(contrastMethods);
-
-import "./CATs.js";
-import "./space-accessors.js";
-
-// Re-export everything
-export default Color;

package/lib/colorjs.io/colorjs.io/src/interpolation.js

@@ -1,222 +0,0 @@
-/**
- * Functions related to color interpolation
- */
-import ColorSpace from "./space.js";
-import {type, interpolate} from "./util.js";
-import getColor from "./getColor.js";
-import clone from "./clone.js";
-import to from "./to.js";
-import toGamut from "./toGamut.js";
-import get from "./get.js";
-import set from "./set.js";
-import defaults from "./defaults.js";
-import * as angles from "./angles.js";
-import deltaE from "./deltaE.js";
-
-/**
- * Return an intermediate color between two colors
- * Signatures: mix(c1, c2, p, options)
- *             mix(c1, c2, options)
- *             mix(color)
- * @param {Color | string} c1 The first color
- * @param {Color | string} [c2] The second color
- * @param {number} [p=.5] A 0-1 percentage where 0 is c1 and 1 is c2
- * @param {Object} [o={}]
- * @return {Color}
- */
-export function mix (c1, c2, p = .5, o = {}) {
-	[c1, c2] = [getColor(c1), getColor(c2)];
-
-	if (type(p) === "object") {
-		[p, o] = [.5, p];
-	}
-
-	let r = range(c1, c2, o);
-	return r(p);
-}
-
-/**
- *
- * @param {Color | string | Function} c1 The first color or a range
- * @param {Color | string} [c2] The second color if c1 is not a range
- * @param {Object} [options={}]
- * @return {Color[]}
- */
-export function steps (c1, c2, options = {}) {
-	let colorRange;
-
-	if (isRange(c1)) {
-		// Tweaking existing range
-		[colorRange, options] = [c1, c2];
-		[c1, c2] = colorRange.rangeArgs.colors;
-	}
-
-	let {
-		maxDeltaE, deltaEMethod,
-		steps = 2, maxSteps = 1000,
-		...rangeOptions
-	} = options;
-
-	if (!colorRange) {
-		[c1, c2] = [getColor(c1), getColor(c2)];
-		colorRange = range(c1, c2, rangeOptions);
-	}
-
-	let totalDelta = deltaE(c1, c2);
-	let actualSteps = maxDeltaE > 0 ? Math.max(steps, Math.ceil(totalDelta / maxDeltaE) + 1) : steps;
-	let ret = [];
-
-	if (maxSteps !== undefined) {
-		actualSteps = Math.min(actualSteps, maxSteps);
-	}
-
-	if (actualSteps === 1) {
-		ret = [{p: .5, color: colorRange(.5)}];
-	}
-	else {
-		let step = 1 / (actualSteps - 1);
-		ret = Array.from({length: actualSteps}, (_, i) => {
-			let p = i * step;
-			return {p, color: colorRange(p)};
-		});
-	}
-
-	if (maxDeltaE > 0) {
-		// Iterate over all stops and find max deltaE
-		let maxDelta = ret.reduce((acc, cur, i) => {
-			if (i === 0) {
-				return 0;
-			}
-
-			let ΔΕ = deltaE(cur.color, ret[i - 1].color, deltaEMethod);
-			return Math.max(acc, ΔΕ);
-		}, 0);
-
-		while (maxDelta > maxDeltaE) {
-			// Insert intermediate stops and measure maxDelta again
-			// We need to do this for all pairs, otherwise the midpoint shifts
-			maxDelta = 0;
-
-			for (let i = 1; (i < ret.length) && (ret.length < maxSteps); i++) {
-				let prev = ret[i - 1];
-				let cur = ret[i];
-
-				let p = (cur.p + prev.p) / 2;
-				let color = colorRange(p);
-				maxDelta = Math.max(maxDelta, deltaE(color, prev.color), deltaE(color, cur.color));
-				ret.splice(i, 0, {p, color: colorRange(p)});
-				i++;
-			}
-		}
-	}
-
-	ret = ret.map(a => a.color);
-
-	return ret;
-}
-
-/**
- * Interpolate to color2 and return a function that takes a 0-1 percentage
- * @param {Color | string | Function} color1 The first color or an existing range
- * @param {Color | string} [color2] If color1 is a color, this is the second color
- * @param {Object} [options={}]
- * @returns {Function} A function that takes a 0-1 percentage and returns a color
- */
-export function range (color1, color2, options = {}) {
-	if (isRange(color1)) {
-		// Tweaking existing range
-		let [r, options] = [color1, color2];
-
-		return range(...r.rangeArgs.colors, {...r.rangeArgs.options, ...options});
-	}
-
-	let {space, outputSpace, progression, premultiplied} = options;
-
-	color1 = getColor(color1);
-	color2 = getColor(color2);
-
-	// Make sure we're working on copies of these colors
-	color1 = clone(color1);
-	color2 = clone(color2);
-
-	let rangeArgs = {colors: [color1, color2], options};
-
-	if (space) {
-		space = ColorSpace.get(space);
-	}
-	else {
-		space = ColorSpace.registry[defaults.interpolationSpace] || color1.space;
-	}
-
-	outputSpace = outputSpace ? ColorSpace.get(outputSpace) : space;
-
-	color1 = to(color1, space);
-	color2 = to(color2, space);
-
-	// Gamut map to avoid areas of flat color
-	color1 = toGamut(color1);
-	color2 = toGamut(color2);
-
-	// Handle hue interpolation
-	// See https://github.com/w3c/csswg-drafts/issues/4735#issuecomment-635741840
-	if (space.coords.h && space.coords.h.type === "angle") {
-		let arc = options.hue = options.hue || "shorter";
-
-		let hue = [space, "h"];
-		let [θ1, θ2] = [get(color1, hue), get(color2, hue)];
-		// Undefined hues must be evaluated before hue fix-up to properly
-		// calculate hue arcs between undefined and defined hues.
-		// See https://github.com/w3c/csswg-drafts/issues/9436#issuecomment-1746957545
-		if (isNaN(θ1) && !isNaN(θ2)) {
-			θ1 = θ2;
-		}
-		else if (isNaN(θ2) && !isNaN(θ1)) {
-			θ2 = θ1;
-		}
-		[θ1, θ2] = angles.adjust(arc, [θ1, θ2]);
-		set(color1, hue, θ1);
-		set(color2, hue, θ2);
-	}
-
-	if (premultiplied) {
-		// not coping with polar spaces yet
-		color1.coords = color1.coords.map(c => c * color1.alpha);
-		color2.coords = color2.coords.map(c => c * color2.alpha);
-	}
-
-	return Object.assign(p => {
-		p = progression ? progression(p) : p;
-		let coords = color1.coords.map((start, i) => {
-			let end = color2.coords[i];
-			return interpolate(start, end, p);
-		});
-
-		let alpha = interpolate(color1.alpha, color2.alpha, p);
-		let ret = {space, coords, alpha};
-
-		if (premultiplied) {
-			// undo premultiplication
-			ret.coords = ret.coords.map(c => c / alpha);
-		}
-
-		if (outputSpace !== space) {
-			ret = to(ret, outputSpace);
-		}
-
-		return ret;
-	}, {
-		rangeArgs,
-	});
-}
-
-export function isRange (val) {
-	return type(val) === "function" && !!val.rangeArgs;
-}
-
-defaults.interpolationSpace = "lab";
-
-export function register (Color) {
-	Color.defineFunction("mix", mix, {returns: "color"});
-	Color.defineFunction("range", range, {returns: "function<color>"});
-	Color.defineFunction("steps", steps, {returns: "array<color>"});
-}