@digdir/designsystemet 0.0.0-deps-tsdown-20260421103939

package/dist/src/colors/utils.js

@@ -0,0 +1,244 @@
+import chroma from "chroma-js";
+import Colorjs from "colorjs.io";
+import { Hsluv } from "hsluv";
+//#region src/colors/utils.ts
+/**
+* Converts a HEX color '#xxxxxx' into a CSS HSL string 'hsl(x,x,x)'
+*
+* @param hex A hex color string
+* @param valuesOnly If true, only the values are returned
+* @returns A CSS HSL string
+*/
+const hexToCssHsl = (hex, valuesOnly = false) => {
+	const [h, s, l] = chroma(hex).hsl();
+	const cssString = `${Math.round(h)},${Math.round(s * 100)}%,${Math.round(l * 100)}%`;
+	return valuesOnly ? cssString : `hsl(${cssString})`;
+};
+/**
+* Converts a HEX string '#xxxxxx' into an array of HSL values '[h,s,l]'
+*
+* @param H A Hex color string
+* @returns HSL values in an array
+*/
+const hexToHSL = (hex) => {
+	const [h, s, l] = chroma(hex).hsl();
+	return [
+		Math.round(h),
+		Math.round(s * 100),
+		Math.round(l * 100)
+	];
+};
+/**
+* Converts a HEX color '#xxxxxx' into an array of HSLuv values '[h,s,l]'
+*
+* @param hex A hex color string
+* @returns
+*/
+const hexToHsluv = (hex) => {
+	const conv = new Hsluv();
+	conv.hex = hex;
+	conv.hexToHsluv();
+	return [
+		conv.hsluv_h,
+		conv.hsluv_s,
+		conv.hsluv_l
+	];
+};
+/**
+* Converts a HSL number array '[h,s,l]' into HSL CSS string 'hsl(x,x,x)'
+*
+* @param HSL A HSL number array '[h,s,l]'
+* @returns A hex color string
+*/
+const hslArrToCss = (HSL) => {
+	return "hsl(" + HSL[0] + "," + HSL[1] + "%," + HSL[2] + "%)";
+};
+/**
+* Converts a HSL CSS string 'hsl(x,x,x)' into an array of HSL values '[h,s,l]'
+*
+* @param h The HSL hue
+* @param s The HSL saturation
+* @param l The HSL lightness
+* @returns HEX color string
+*/
+const HSLToHex = (h, s, l) => {
+	return chroma.hsl(h, s / 100, l / 100).hex();
+};
+/**
+* Converts a HEX color '#xxxxxx' into an array of RGB values '[R, G, B]'
+*
+* @param hex A hex color string
+* @param type The type of RGB values to return
+* @returns RGB values in an array
+*/
+const hexToRgb = (hex, type = "255") => {
+	const rgb = chroma(hex).rgb();
+	return {
+		r: type === "255" ? rgb[0] : rgb[0] / 255,
+		g: type === "255" ? rgb[1] : rgb[1] / 255,
+		b: type === "255" ? rgb[2] : rgb[2] / 255
+	};
+};
+/**
+* Get the contrast ratio between two HEX colors
+*
+* @param color1 The first color to compare
+* @param color2 The second color to compare
+* @returns
+*/
+const getContrastFromHex = (color1, color2) => {
+	const lum1 = chroma(color1).luminance();
+	const lum2 = chroma(color2).luminance();
+	return (Math.max(lum1, lum2) + .05) / (Math.min(lum1, lum2) + .05);
+};
+/**
+* Get the contrast ratio between two colors at a specific lightness
+*
+* @param lightness The lightness value
+* @param mainColor The main color
+* @param backgroundColor The background color
+* @returns The contrast ratio
+*/
+const getContrastFromLightness = (lightness, mainColor, backgroundColor) => {
+	const conv = new Hsluv();
+	conv.hex = mainColor;
+	conv.hexToHsluv();
+	conv.hsluv_l = lightness;
+	conv.hsluvToHex();
+	const lightMainColor = conv.hex;
+	const lum1 = chroma(lightMainColor).luminance();
+	const lum2 = chroma(backgroundColor).luminance();
+	return (Math.max(lum1, lum2) + .05) / (Math.min(lum1, lum2) + .05);
+};
+/**
+* Check if two colors have enough contrast to be used together
+*
+* @param color1 The first color
+* @param color2 The second color
+* @returns If the colors have enough contrast
+*/
+const areColorsContrasting = (color1, color2, type = "aa") => {
+	const contrast = getContrastFromHex(color1, color2);
+	if (contrast !== null) {
+		if (type === "aaa") return contrast >= 7;
+		if (type === "aa") return contrast >= 4.5;
+		return contrast >= 3;
+	}
+	return false;
+};
+/**
+* Check if aa string value is a HEX color
+*
+* @param hex The hex color
+*/
+const isHexColor = (hex) => {
+	return typeof hex === "string" && hex.length === 6 && !Number.isNaN(Number("0x" + hex));
+};
+/**
+* Get the luminance value from a lightness value
+*
+* @param lightness The lightness value
+*/
+const getLuminanceFromLightness = (lightness) => {
+	const conv = new Hsluv();
+	conv.hsluv_l = lightness;
+	conv.hsluvToHex();
+	return chroma(conv.hex).luminance();
+};
+/**
+* Get the relative luminance from any valid css color
+*
+* @param color
+*/
+const getLuminanceFromColor = (color) => {
+	return chroma(color).luminance();
+};
+/**
+* Get the HSLuv lightness from a HEX color
+*
+* @param hex The hex color
+*/
+const getLightnessFromHex = (hex) => {
+	const conv = new Hsluv();
+	conv.hex = hex;
+	conv.hexToHsluv();
+	return conv.hsluv_l;
+};
+/**
+*
+* This function checks if white or black text can be used on 2 different colors at 4.5:1 contrast.
+*
+* @param baseDefaultColor Base default color
+* @param baseActiveColor Base active color
+*/
+const canTextBeUsedOnColors = (baseDefaultColor, baseActiveColor) => {
+	const defaultAgainstWhite = getContrastFromHex(baseDefaultColor, "#ffffff");
+	const defaultAgainstBlack = getContrastFromHex(baseDefaultColor, "#000000");
+	const activeAgainstWhite = getContrastFromHex(baseActiveColor, "#ffffff");
+	const activeAgainstBlack = getContrastFromHex(baseActiveColor, "#000000");
+	if (defaultAgainstWhite >= 4.5 && activeAgainstWhite >= 4.5) return true;
+	if (defaultAgainstBlack >= 4.5 && activeAgainstBlack >= 4.5) return true;
+	return false;
+};
+/**
+* Converts a color to a HEX color
+*
+* @param color
+* @returns
+*/
+const convertToHex = (color) => {
+	if (!color) return "#000000";
+	if (/^#[0-9A-Fa-f]{6}$/.test(color)) return color;
+	return chroma(color).hex();
+};
+const rgbToHex = (rgb) => {
+	return `#${[
+		rgb.r,
+		rgb.g,
+		rgb.b
+	].map((x) => {
+		const hex = Math.round(x * 255).toString(16);
+		return hex.length === 1 ? "0" + hex : hex;
+	}).join("")}`;
+};
+/**
+* Convert a color to a different format
+*
+* @param cssColor Any valid css color
+* @param format Color space/format supported here https://colorjs.io/docs/spaces
+*/
+const convertColor = (cssColor, format) => {
+	const color = new Colorjs(cssColor);
+	switch (format) {
+		case "rgb":
+		case "rgba": return color.toString({
+			format: {
+				name: format,
+				coords: [
+					"<number>[0, 255]",
+					"<number>[0, 255]",
+					"<number>[0, 255]"
+				]
+			},
+			precision: 3
+		});
+		case "hex": return color.toString({
+			format,
+			precision: 3
+		});
+		case "hct": return color.to(format).toString({
+			format: {
+				name: format,
+				coords: [
+					"<number>",
+					"<number>",
+					"<number>"
+				]
+			},
+			precision: 3
+		});
+		default: return color.to(format).toString({ precision: 3 });
+	}
+};
+//#endregion
+export { HSLToHex, areColorsContrasting, canTextBeUsedOnColors, convertColor, convertToHex, getContrastFromHex, getContrastFromLightness, getLightnessFromHex, getLuminanceFromColor, getLuminanceFromLightness, hexToCssHsl, hexToHSL, hexToHsluv, hexToRgb, hslArrToCss, isHexColor, rgbToHex };

package/dist/src/config.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+/**
+ * Validates a configuration object against a provided Zod schema.
+ *
+ * @template T - The expected type of the validated configuration.
+ * @param schema - A Zod schema used to validate the configuration object.
+ * @param unvalidatedConfig - The configuration object to validate.
+ * @returns The validated configuration object, typed as T.
+ * @throws Exits the process with code 1 if validation fails, after logging a friendly error message.
+ */
+export declare function validateConfig<T>(schema: z.ZodType<T>, unvalidatedConfig: Record<string, unknown>, configFilePath: string): T;
+export declare function parseConfig<T>(configFile: string, configFilePath: string): T;
+export declare const colorRegex: RegExp;
+declare const overridesSchema: z.ZodOptional<z.ZodObject<{
+    colors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{
+        "background-default": "background-default";
+        "background-tinted": "background-tinted";
+        "surface-default": "surface-default";
+        "surface-tinted": "surface-tinted";
+        "surface-hover": "surface-hover";
+        "surface-active": "surface-active";
+        "border-subtle": "border-subtle";
+        "border-default": "border-default";
+        "border-strong": "border-strong";
+        "text-subtle": "text-subtle";
+        "text-default": "text-default";
+        "base-default": "base-default";
+        "base-hover": "base-hover";
+        "base-active": "base-active";
+        "base-contrast-subtle": "base-contrast-subtle";
+        "base-contrast-default": "base-contrast-default";
+    }> & z.core.$partial, z.ZodObject<{
+        light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+    }, z.core.$strip>>>>;
+    severity: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        danger: "danger";
+        info: "info";
+        success: "success";
+        warning: "warning";
+    }> & z.core.$partial, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+    linkVisited: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+    }, z.core.$strip>>;
+    focus: z.ZodOptional<z.ZodObject<{
+        inner: z.ZodOptional<z.ZodObject<{
+            light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        }, z.core.$strip>>;
+        outer: z.ZodOptional<z.ZodObject<{
+            light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+declare const themeSchema: z.ZodObject<{
+    colors: z.ZodObject<{
+        main: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        support: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+        neutral: z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>;
+    }, z.core.$strip>;
+    typography: z.ZodOptional<z.ZodObject<{
+        fontFamily: z.ZodString;
+    }, z.core.$strip>>;
+    borderRadius: z.ZodOptional<z.ZodNumber>;
+    overrides: z.ZodOptional<z.ZodObject<{
+        colors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{
+            "background-default": "background-default";
+            "background-tinted": "background-tinted";
+            "surface-default": "surface-default";
+            "surface-tinted": "surface-tinted";
+            "surface-hover": "surface-hover";
+            "surface-active": "surface-active";
+            "border-subtle": "border-subtle";
+            "border-default": "border-default";
+            "border-strong": "border-strong";
+            "text-subtle": "text-subtle";
+            "text-default": "text-default";
+            "base-default": "base-default";
+            "base-hover": "base-hover";
+            "base-active": "base-active";
+            "base-contrast-subtle": "base-contrast-subtle";
+            "base-contrast-default": "base-contrast-default";
+        }> & z.core.$partial, z.ZodObject<{
+            light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        }, z.core.$strip>>>>;
+        severity: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            danger: "danger";
+            info: "info";
+            success: "success";
+            warning: "warning";
+        }> & z.core.$partial, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+        linkVisited: z.ZodOptional<z.ZodObject<{
+            light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        }, z.core.$strip>>;
+        focus: z.ZodOptional<z.ZodObject<{
+            inner: z.ZodOptional<z.ZodObject<{
+                light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            }, z.core.$strip>>;
+            outer: z.ZodOptional<z.ZodObject<{
+                light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const commonConfig: z.ZodObject<{
+    clean: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * This defines the structure of the final configuration file
+ */
+export declare const configFileCreateSchema: z.ZodObject<{
+    outDir: z.ZodNonOptional<z.ZodString>;
+    themes: z.ZodNonOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        colors: z.ZodObject<{
+            main: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            support: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+            neutral: z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>;
+        }, z.core.$strip>;
+        typography: z.ZodOptional<z.ZodObject<{
+            fontFamily: z.ZodString;
+        }, z.core.$strip>>;
+        borderRadius: z.ZodOptional<z.ZodNumber>;
+        overrides: z.ZodOptional<z.ZodObject<{
+            colors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{
+                "background-default": "background-default";
+                "background-tinted": "background-tinted";
+                "surface-default": "surface-default";
+                "surface-tinted": "surface-tinted";
+                "surface-hover": "surface-hover";
+                "surface-active": "surface-active";
+                "border-subtle": "border-subtle";
+                "border-default": "border-default";
+                "border-strong": "border-strong";
+                "text-subtle": "text-subtle";
+                "text-default": "text-default";
+                "base-default": "base-default";
+                "base-hover": "base-hover";
+                "base-active": "base-active";
+                "base-contrast-subtle": "base-contrast-subtle";
+                "base-contrast-default": "base-contrast-default";
+            }> & z.core.$partial, z.ZodObject<{
+                light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            }, z.core.$strip>>>>;
+            severity: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                danger: "danger";
+                info: "info";
+                success: "success";
+                warning: "warning";
+            }> & z.core.$partial, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+            linkVisited: z.ZodOptional<z.ZodObject<{
+                light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            }, z.core.$strip>>;
+            focus: z.ZodOptional<z.ZodObject<{
+                inner: z.ZodOptional<z.ZodObject<{
+                    light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                    dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                }, z.core.$strip>>;
+                outer: z.ZodOptional<z.ZodObject<{
+                    light: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                    dark: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    clean: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CommonConfigSchema = z.infer<typeof commonConfig>;
+export type BuildConfigSchema = z.infer<typeof commonConfig>;
+export type CreateConfigSchema = z.infer<typeof configFileCreateSchema>;
+export type ConfigSchemaTheme = z.infer<typeof themeSchema>;
+export type ColorOverrideSchema = z.infer<typeof overridesSchema>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuCxB;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,cAAc,EAAE,MAAM,GACrB,CAAC,CAUH;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC,CAe5E;AAWD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAuEnE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQR,CAAC;AAEd,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBmG,CAAC;AAErH,eAAO,MAAM,YAAY;;iBAEvB,CAAC;AAYH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqD,CAAC;AACzF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/src/config.js

@@ -0,0 +1,118 @@
+import { baseColorNames, colorNames } from "./colors/colorMetadata.js";
+import { convertToHex } from "./colors/utils.js";
+import { RESERVED_COLORS } from "./colors/theme.js";
+import "./colors/index.js";
+import { cliOptions } from "./tokens/create.js";
+import pc from "picocolors";
+import * as R from "ramda";
+import { z } from "zod";
+import { fromError } from "zod-validation-error";
+//#region src/config.ts
+function mapPathToOptionName(path) {
+	const normalisedPath = path[0] === "themes" ? ["theme", ...R.drop(2, path)] : path;
+	const option = R.path(normalisedPath, cliOptions);
+	if (typeof option !== "string") return;
+	return option;
+}
+function makeFriendlyError(err) {
+	try {
+		return fromError(err, { messageBuilder: (issues) => issues.map((issue) => {
+			const issuePath = issue.path.join(".");
+			const optionName = mapPathToOptionName(issue.path);
+			const errorCode = `(error code: ${issue.code})`;
+			const optionMessage = optionName ? ` or CLI option --${optionName}` : "";
+			return `  - Error in JSON value ${pc.red(issuePath)}${optionMessage}:
+      ${issue.message} ${pc.dim(errorCode)}`;
+		}).join("\n") });
+	} catch (_err2) {
+		console.error(pc.red(err instanceof Error ? err.message : "Unknown error occurred while parsing config file"));
+		console.error(err instanceof Error ? err.stack : "No stack trace available");
+	}
+}
+/**
+* Validates a configuration object against a provided Zod schema.
+*
+* @template T - The expected type of the validated configuration.
+* @param schema - A Zod schema used to validate the configuration object.
+* @param unvalidatedConfig - The configuration object to validate.
+* @returns The validated configuration object, typed as T.
+* @throws Exits the process with code 1 if validation fails, after logging a friendly error message.
+*/
+function validateConfig(schema, unvalidatedConfig, configFilePath) {
+	try {
+		return schema.parse(unvalidatedConfig);
+	} catch (err) {
+		console.error(pc.redBright(`Invalid config file at ${pc.red(configFilePath)}`));
+		const validationError = makeFriendlyError(err);
+		console.error(validationError?.toString());
+		process.exit(1);
+	}
+}
+function parseConfig(configFile, configFilePath) {
+	if (!configFile) return {};
+	try {
+		return JSON.parse(configFile);
+	} catch (err) {
+		console.error(pc.redBright(`Failed parsing config file at ${pc.red(configFilePath)}`));
+		const validationError = makeFriendlyError(err);
+		console.error(validationError?.toString());
+		process.exit(1);
+	}
+}
+const hexPatterns = [
+	`#[0-9a-fA-F]{3}`,
+	`#[0-9a-fA-F]{4}`,
+	`#[0-9a-fA-F]{6}`,
+	`#[0-9a-fA-F]{8}`
+];
+const reservedColorsPattern = `^(?!(?:${RESERVED_COLORS.join("|")})$)`;
+const colorRegex = new RegExp(`^${hexPatterns.join("|")}$`);
+const colorSchema = z.string().regex(colorRegex).transform(convertToHex).describe(`A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`);
+const colorCategorySchema = z.record(z.string().regex(new RegExp(reservedColorsPattern, "i"), { error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}` }), colorSchema, { error: "Color definitions must be hex color values" }).refine((colors) => !Object.keys(colors).some((key) => RESERVED_COLORS.includes(key.toLowerCase())), { error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}` }).describe("An object with one or more color definitions. The property name is used as the color name.");
+const colorModeOverrideSchema = z.object({
+	light: colorSchema.optional().describe("A hex color that overrides light mode"),
+	dark: colorSchema.optional().describe("A hex color that overrides dark mode")
+}).describe("Override values for semantic color tokens like \"background-subtle\", \"border-default\", etc.");
+const colorWeightOverrideSchema = z.partialRecord(z.enum([...colorNames]), colorModeOverrideSchema).describe("The name of the color to add overrides for, e.g. \"accent\"");
+const semanticColorOverrideSchema = z.record(z.string(), colorWeightOverrideSchema).describe("An object with color names as keys");
+const severityColorOverrideSchema = z.partialRecord(z.enum(baseColorNames), colorSchema.describe("A hex color, which is used for creating a color scale")).optional().describe("An object with severity color names as keys");
+const linkVisitedOverrideSchema = z.object({
+	light: colorSchema.optional().describe("A hex color that overrides light mode"),
+	dark: colorSchema.optional().describe("A hex color that overrides dark mode")
+}).describe("Overrides for the \"link-visited\" color");
+const focusOverrideSchema = z.object({
+	inner: z.object({
+		light: colorSchema.optional().describe("A hex color that overrides light mode"),
+		dark: colorSchema.optional().describe("A hex color that overrides dark mode")
+	}).optional().describe("Overrides for the \"focus-inner\" color"),
+	outer: z.object({
+		light: colorSchema.optional().describe("A hex color that overrides light mode"),
+		dark: colorSchema.optional().describe("A hex color that overrides dark mode")
+	}).optional().describe("Overrides for the \"focus-outer\" color")
+}).describe("Overrides for the focus colors");
+const overridesSchema = z.object({
+	colors: semanticColorOverrideSchema.optional(),
+	severity: severityColorOverrideSchema.optional(),
+	linkVisited: linkVisitedOverrideSchema.optional(),
+	focus: focusOverrideSchema.optional()
+}).describe("Overrides for generated design tokens. Currently only supports colors defined in your theme").optional();
+const themeSchema = z.object({
+	colors: z.object({
+		main: colorCategorySchema,
+		support: colorCategorySchema.optional().default({}),
+		neutral: colorSchema.describe("A hex color, which is used for creating a color scale.")
+	}).meta({ description: "Defines the colors for this theme" }),
+	typography: z.object({ fontFamily: z.string().meta({ description: "Sets the font-family for this theme" }) }).describe("Defines the typography for a given theme").optional(),
+	borderRadius: z.number().meta({ description: "Defines the border-radius for this theme" }).optional(),
+	overrides: overridesSchema
+}).meta({ description: "An object defining a theme. The property name holding the object becomes the theme name." });
+const commonConfig = z.object({ clean: z.boolean().meta({ description: "Delete the output directory before building or creating tokens" }).optional() });
+/**
+* This defines the structure of the final configuration file
+*/
+const configFileCreateSchema = z.object({
+	outDir: z.string().meta({ description: "Path to the output directory for the created design tokens" }),
+	themes: z.record(z.string(), themeSchema).meta({ description: "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name." })
+}).required().extend(commonConfig.shape);
+//#endregion
+export { colorRegex, commonConfig, configFileCreateSchema, parseConfig, validateConfig };

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './colors/index.js';
+export { type CreateConfigSchema as ConfigSchema, configFileCreateSchema as configSchema, } from './config.js';
+export * from './tokens/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,OAAO,EACL,KAAK,kBAAkB,IAAI,YAAY,EACvC,sBAAsB,IAAI,YAAY,GACvC,MAAM,aAAa,CAAC;AACrB,cAAc,mBAAmB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,10 @@
+import { baseColorNames, baseColors, colorMetadata, colorNames, dsLinkColor, getColorMetadataByNumber } from "./colors/colorMetadata.js";
+import { HSLToHex, areColorsContrasting, canTextBeUsedOnColors, convertColor, convertToHex, getContrastFromHex, getContrastFromLightness, getLightnessFromHex, getLuminanceFromColor, getLuminanceFromLightness, hexToCssHsl, hexToHSL, hexToHsluv, hexToRgb, hslArrToCss, isHexColor, rgbToHex } from "./colors/utils.js";
+import { RESERVED_COLORS, generateColorContrast, generateColorScale, generateColorSchemes, getCssVariable } from "./colors/theme.js";
+import { semanticColorMap, semanticColorNames, semanticColorNumbers } from "./colors/types.js";
+import "./colors/index.js";
+import { cliOptions, createTokens } from "./tokens/create.js";
+import { configFileCreateSchema } from "./config.js";
+import { formatThemeCSS, formatTokens } from "./tokens/format.js";
+import "./tokens/index.js";
+export { HSLToHex, RESERVED_COLORS, areColorsContrasting, baseColorNames, baseColors, canTextBeUsedOnColors, cliOptions, colorMetadata, colorNames, configFileCreateSchema as configSchema, convertColor, convertToHex, createTokens, dsLinkColor, formatThemeCSS, formatTokens, generateColorContrast, generateColorScale, generateColorSchemes, getColorMetadataByNumber, getContrastFromHex, getContrastFromLightness, getCssVariable, getLightnessFromHex, getLuminanceFromColor, getLuminanceFromLightness, hexToCssHsl, hexToHSL, hexToHsluv, hexToRgb, hslArrToCss, isHexColor, rgbToHex, semanticColorMap, semanticColorNames, semanticColorNumbers };

package/dist/src/migrations/beta-to-v1.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (glob?: string) => Promise<void>;
+export default _default;
+//# sourceMappingURL=beta-to-v1.d.ts.map

package/dist/src/migrations/beta-to-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beta-to-v1.d.ts","sourceRoot":"","sources":["../../../src/migrations/beta-to-v1.ts"],"names":[],"mappings":"yBAGgB,OAAO,MAAM;AAA7B,wBAmVK"}