@digdir/designsystemet 0.1.0-next.21 → 0.1.0-next.23

package/dist/src/tokens/configs.js

@@ -1,14 +1,14 @@
-import * as tokenStudio from "@tokens-studio/sd-transforms";
+import { register } from "@tokens-studio/sd-transforms";
 import * as R from "ramda";
 import StyleDictionary from "style-dictionary";
 import { outputReferencesFilter } from "style-dictionary/utils";
-import { makeEntryFile } from "./actions.js";
 import * as formats from "./formats/css.js";
 import { jsTokens } from "./formats/js-tokens.js";
 import { nameKebab, sizeRem, typographyShorthand } from "./transformers.js";
 import { permutateThemes as permutateThemes_ } from "./utils/permutateThemes.js";
-import { typeEquals } from "./utils/utils.js";
-void tokenStudio.registerTransforms(StyleDictionary);
+import { pathStartsWithOneOf, typeEquals } from "./utils/utils.js";
+void register(StyleDictionary, { withSDBuiltins: false });
+const usesDtcg = true;
 const prefix = "ds";
 const basePxFontSize = 16;
 const separator = "_";
@@ -20,7 +20,6 @@ StyleDictionary.registerFormat(jsTokens);
 StyleDictionary.registerFormat(formats.colormode);
 StyleDictionary.registerFormat(formats.semantic);
 StyleDictionary.registerFormat(formats.typography);
-StyleDictionary.registerAction(makeEntryFile);
 const dsTransformers = [
   nameKebab.name,
   `ts/resolveMath`,
@@ -31,7 +30,7 @@ const dsTransformers = [
   "ts/color/modifiers",
   "ts/color/css/hexrgba",
   "ts/size/lineheight",
-  "ts/shadow/css/shorthand"
+  "shadow/css/shorthand"
 ];
 const paritionPrimitives = R.partition(R.test(/(?!.*global\.json).*primitives.*/));
 const hasUnknownProps = R.pipe(R.values, R.none(R.equals("unknown")), R.not);
@@ -48,6 +47,7 @@ const colorModeVariables = ({ mode = "light", outPath, theme }) => {
   const selector = `${mode === "light" ? ":root, " : ""}[data-ds-color-mode="${mode}"]`;
   const layer = `ds.theme.color-mode.${mode}`;
   return {
+    usesDtcg,
     log: { verbosity: "silent" },
     preprocessors: ["tokens-studio"],
     platforms: {
@@ -62,7 +62,6 @@ const colorModeVariables = ({ mode = "light", outPath, theme }) => {
         prefix,
         buildPath: `${outPath}/${theme}/`,
         transforms: dsTransformers,
-        actions: [makeEntryFile.name],
         files: [
           {
             destination: `color-mode/${mode}.css`,
@@ -81,8 +80,9 @@ const colorModeVariables = ({ mode = "light", outPath, theme }) => {
 const semanticVariables = ({ outPath, theme }) => {
   const selector = `:root`;
   const layer = `ds.theme.semantic`;
-  const isCalculatedToken = (token) => typeEquals(["spacing", "sizing", "borderRadius"], token);
+  const isCalculatedToken = (token) => pathStartsWithOneOf(["spacing", "sizing", "border-radius"], token);
   return {
+    usesDtcg,
     log: { verbosity: "silent" },
     preprocessors: ["tokens-studio"],
     platforms: {
@@ -98,12 +98,11 @@ const semanticVariables = ({ outPath, theme }) => {
         prefix,
         buildPath: `${outPath}/${theme}/`,
         transforms: dsTransformers,
-        actions: [makeEntryFile.name],
         files: [
           {
             destination: `semantic.css`,
             format: formats.semantic.name,
-            filter: (token) => (!token.isSource || isCalculatedToken(token)) && !typeEquals(["color", "fontWeights", "fontFamilies"], token)
+            filter: (token) => (!token.isSource || isCalculatedToken(token)) && !typeEquals(["color", "fontWeight", "fontFamily"], token)
           }
         ],
         options: {
@@ -116,6 +115,7 @@ const semanticVariables = ({ outPath, theme }) => {
 };
 const typescriptTokens = ({ mode = "unknown", outPath, theme }) => {
   return {
+    usesDtcg,
     log: { verbosity: "silent" },
     preprocessors: ["tokens-studio"],
     platforms: {
@@ -130,9 +130,8 @@ const typescriptTokens = ({ mode = "unknown", outPath, theme }) => {
             format: jsTokens.name,
             outputReferences: outputColorReferences,
             filter: (token) => {
-              if (R.test(/primitives\/modes|\/themes/, token.filePath)) {
-                return false;
-              }
+              if (R.test(/primitives\/modes|\/themes/, token.filePath)) return false;
+              if (pathStartsWithOneOf(["border-width"], token)) return false;
               if (R.test(/accent|neutral|brand1|brand2|brand3|success|danger|warning/, token.name) || R.includes("semantic", token.filePath)) {
                 return true;
               }
@@ -151,6 +150,7 @@ const typographyCSS = ({ outPath, theme, typography }) => {
   const selector = `${typography === "primary" ? ":root, " : ""}[data-ds-typography="${typography}"]`;
   const layer = `ds.theme.typography.${typography}`;
   return {
+    usesDtcg: true,
     log: { verbosity: "silent" },
     preprocessors: ["tokens-studio"],
     platforms: {
@@ -167,10 +167,14 @@ const typographyCSS = ({ outPath, theme, typography }) => {
             destination: `typography/${typography}.css`,
             format: formats.typography.name,
             filter: (token) => {
-              return typeEquals(
-                ["typography", "fontweights", "fontfamilies", "lineheights", "fontsizes", "letterSpacing"],
+              const included = typeEquals(
+                ["typography", "fontweight", "fontFamily", "lineheight", "fontsize", "dimension", "font"],
+                token
+              );
+              return included && !pathStartsWithOneOf(
+                ["spacing", "sizing", "border-width", "border-radius", "theme", "theme2", "theme3", "theme4"],
                 token
-              ) && !(token.path[0] || "").startsWith("theme");
+              );
             }
           }
         ],

package/dist/src/tokens/formats/css.js

@@ -11,14 +11,15 @@ const colormode = {
   name: "ds/css-colormode",
   format: async ({ dictionary, file, options, platform }) => {
     const { allTokens } = dictionary;
-    const { outputReferences } = options;
+    const { outputReferences, usesDtcg } = options;
     const { selector, mode, layer } = platform;
     const mode_ = mode;
     const header = await fileHeader({ file });
     const format = createPropertyFormatter({
       outputReferences,
       dictionary,
-      format: "css"
+      format: "css",
+      usesDtcg
     });
     const colorSchemeProperty = mode_ === "dark" || mode_ === "light" ? `color-scheme: ${mode_};
 ` : "";
@@ -27,10 +28,12 @@ ${allTokens.map(format).join("\n")}
 ${colorSchemeProperty}}
 `;
     const autoSelectorContent = ["light", "dark"].includes(mode_) ? prefersColorScheme(mode_, content) : "";
-    return header + `@layer ${layer} {
+    const body = R.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content} ${autoSelectorContent}
 }
+` : `${selector} ${content} ${autoSelectorContent}
 `;
+    return header + body;
   }
 };
 const calculatedVariable = R.pipe(R.split(/:(.*?);/g), (split) => `${split[0]}: calc(${R.trim(split[1])});`);
@@ -38,13 +41,14 @@ const semantic = {
   name: "ds/css-semantic",
   format: async ({ dictionary, file, options, platform }) => {
     const { allTokens } = dictionary;
-    const { outputReferences } = options;
+    const { outputReferences, usesDtcg } = options;
     const { selector, isCalculatedToken, layer } = platform;
     const header = await fileHeader({ file });
     const format = createPropertyFormatter({
       outputReferences,
       dictionary,
-      format: "css"
+      format: "css",
+      usesDtcg
     });
     const formatTokens = R.map((token) => {
       const originalValue = getValue(token.original);
@@ -60,13 +64,15 @@ const semantic = {
 ${formattedVariables.join("\n")}
 }
 `;
-    return header + `@layer ${layer} {
+    const body = R.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content}
 }
+` : `${selector} ${content}
 `;
+    return header + body;
   }
 };
-const sortByType = R.sortBy((token) => token?.type === "typography");
+const sortByType = R.sortBy((token) => token?.$type === "typography");
 const getVariableName = R.pipe(
   R.split(":"),
   R.head,
@@ -92,61 +98,66 @@ const sortTypographyLast = R.sortWith([
 const typography = {
   name: "ds/css-typography",
   format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences } = options;
+    const { outputReferences, usesDtcg } = options;
     const { selector, layer } = platform;
     const header = await fileHeader({ file });
     const format = createPropertyFormatter({
       outputReferences,
       dictionary,
-      format: "css"
+      format: "css",
+      usesDtcg
     });
     const sortedTokens = sortTypographyLast(dictionary.allTokens);
     const formattedTokens = R.pipe(
       sortByType,
       R.reduce(
         (acc, token) => {
-          if (typeEquals("fontweights", token)) {
+          if (typeEquals("fontweight", token)) {
             const className = `
   .${classSelector(token)} {
     font-weight: ${getValue(token)};
   }`;
-            return {
-              ...acc,
+            return Object.assign(acc, {
               variables: [...acc.variables, format(token)],
               classes: [...acc.classes, className]
-            };
+            });
           }
-          if (typeEquals("lineheights", token)) {
+          if (typeEquals("lineheight", token)) {
             const className = `
   .${classSelector(token)} {
     line-height: ${getValue(token)};
   }`;
-            return {
-              ...acc,
+            return Object.assign(acc, {
               variables: [...acc.variables, format(token)],
               classes: [...acc.classes, className]
-            };
+            });
           }
           if (typeEquals("typography", token)) {
-            const references = getReferences(getValue(token.original), dictionary.tokens);
-            const fontweight = R.find(typeEquals(["fontweights"]))(references);
-            const lineheight = R.find(typeEquals(["lineheights"]))(references);
-            const fontsize = R.find(typeEquals(["fontsizes"]))(references);
-            const letterSpacing = R.find(typeEquals(["letterSpacing"]))(references);
+            let references = [];
+            try {
+              references = getReferences(getValue(token.original), dictionary.tokens);
+            } catch (error) {
+              console.error("Error getting references", error);
+              throw new Error(JSON.stringify(token, null, 2));
+            }
+            const fontweight = R.find(typeEquals(["fontweight"]))(references);
+            const lineheight = R.find(typeEquals(["lineheight"]))(references);
+            const fontsize = R.find(typeEquals(["fontsize"]))(references);
+            const letterSpacing = R.find(typeEquals(["dimension"]))(references);
             const fontSizeVar = fontsize ? getVariableName(format(fontsize)) : null;
             const fontWeightVar = fontweight ? getVariableName(format(fontweight)) : null;
             const lineheightVar = lineheight ? getVariableName(format(lineheight)) : null;
             const letterSpacingVar = letterSpacing ? getVariableName(format(letterSpacing)) : null;
             const className = `
   .${classSelector(token)} {
-    ${fontSizeVar && `font-size: ${fontSizeVar};`}
-    ${lineheightVar && `line-height: ${lineheightVar};`}
-    ${fontWeightVar && `font-weight: ${fontWeightVar};`}
-    ${letterSpacingVar && `letter-spacing: ${letterSpacingVar};`}
+    ${fontSizeVar ? `font-size: ${fontSizeVar};` : ""}
+    ${lineheightVar ? `line-height: ${lineheightVar};` : ""}
+    ${fontWeightVar ? `font-weight: ${fontWeightVar};` : ""}
+    ${letterSpacingVar ? `letter-spacing: ${letterSpacingVar};` : ""}
   }`;
-            return { ...acc, classes: [className, ...acc.classes] };
+            return Object.assign(acc, { classes: [className, ...acc.classes] });
           }
-          return { ...acc, variables: [...acc.variables, format(token)] };
+          return Object.assign(acc, { variables: [...acc.variables, format(token)] });
         },
         { variables: [], classes: [] }
       )
@@ -157,10 +168,10 @@ const typography = {
 ${variables}
 ${classes}
 }` : classes;
-    return header + `@layer ${layer} {
+    const body = R.isNotNil(layer) ? `@layer ${layer} {
 ${content}
-}
-`;
+}` : content;
+    return header + body;
   }
 };
 export {

package/dist/src/tokens/formats/js-tokens.js

@@ -3,21 +3,25 @@ import { createPropertyFormatter, fileHeader } from "style-dictionary/utils";
 import { getType } from "../utils/utils.js";
 const groupByType = R.groupBy((token) => getType(token));
 const removeUnwatedTokens = R.filter(
-  (token) => !["fds-base_spacing", "fds-base_sizing"].includes(token.name)
+  (token) => !["ds-base-spacing", "ds-base-sizing"].includes(token.name)
 );
+const dissocExtensions = R.pipe(R.dissoc("$extensions"), R.dissocPath(["original", "$extensions"]));
+const removeUnwatedProps = R.map((token) => dissocExtensions(token));
 const toCssVarName = R.pipe(R.split(":"), R.head, R.trim);
 const jsTokens = {
   name: "ds/js-tokens",
-  format: async ({ dictionary, file }) => {
+  format: async ({ dictionary, file, options }) => {
+    const { usesDtcg } = options;
     const format = createPropertyFormatter({
       dictionary,
-      format: "css"
+      format: "css",
+      usesDtcg
     });
     const formatTokens = R.map((token) => ({
       ...token,
       name: toCssVarName(format(token))
     }));
-    const processTokens = R.pipe(removeUnwatedTokens, formatTokens, groupByType);
+    const processTokens = R.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
     const tokens = processTokens(dictionary.allTokens);
     const content = Object.entries(tokens).map(
       ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 

package/dist/src/tokens/transformers.js

@@ -1,12 +1,16 @@
 import * as R from "ramda";
 import { noCase } from "./utils/noCase.js";
-import { getValue, typeEquals } from "./utils/utils.js";
+import { getValue, pathStartsWithOneOf, typeEquals } from "./utils/utils.js";
 const isPx = R.test(/\b\d+px\b/g);
 const sizeRem = {
   name: "ds/size/toRem",
   type: "value",
   transitive: true,
-  filter: (token) => typeEquals(["sizing", "spacing", "borderRadius", "fontsizes"], token),
+  filter: (token) => {
+    const hasWantedType = typeEquals(["dimension", "fontsize"], token);
+    const hasWantedPath = pathStartsWithOneOf(["spacing", "sizing", "border-radius", "font-size"], token);
+    return hasWantedType && hasWantedPath;
+  },
   transform: (token, config) => {
     const value = getValue(token);
     if (isPx(value)) {
@@ -34,7 +38,7 @@ const typographyShorthand = {
   name: "typography/shorthand",
   type: "value",
   transitive: true,
-  filter: (token) => token.type === "typography",
+  filter: (token) => typeEquals("typography", token),
   transform: (token) => {
     const typography = getValue(token);
     return `${typography.fontWeight} ${typography.fontSize}/${typography.lineHeight} '${typography.fontFamily}'`;

package/dist/src/tokens/utils/entryfile.js

@@ -0,0 +1,31 @@
+import glob from "fast-glob";
+import fs from "fs-extra";
+import * as R from "ramda";
+const sortLightmodeFirst = R.sortWith([R.descend(R.includes("light")), R.descend(R.includes("secondary"))]);
+const header = `@charset "UTF-8";
+
+@layer ds.reset, ds.theme, ds.base, ds.utilities, ds.components;
+
+`;
+const sortAndConcat = R.pipe(
+  sortLightmodeFirst,
+  R.map((file) => {
+    try {
+      const content = fs.readFileSync(file, "utf-8").toString();
+      return content;
+    } catch (e) {
+      console.error(`Error reading file: ${file}`);
+      return "";
+    }
+  }),
+  R.join("\n")
+);
+const makeEntryFile = async ({ outPath, buildPath, theme }) => {
+  const writePath = `${outPath}/${theme}.css`;
+  const files = await glob(`**/*`, { cwd: buildPath });
+  const content = header + sortAndConcat(files.map((file) => `${buildPath}/${file}`));
+  await fs.writeFile(writePath, content);
+};
+export {
+  makeEntryFile
+};

package/dist/src/tokens/utils/permutateThemes.js

@@ -8,7 +8,7 @@ function permutateThemes(themes, { separator = "-" } = {}) {
     return mapThemesToSetsObject(themes);
   }
   const groups = {};
-  themes.forEach((theme) => {
+  for (const theme of themes) {
     if (theme.group) {
       groups[theme.group] = [...groups[theme.group] ?? [], theme];
     } else {
@@ -16,7 +16,7 @@ function permutateThemes(themes, { separator = "-" } = {}) {
         `Theme ${theme.name} does not have a group property, which is required for multi-dimensional theming.`
       );
     }
-  });
+  }
   if (Object.keys(groups).length <= 1) {
     return mapThemesToSetsObject(themes);
   }

package/dist/src/tokens/utils/utils.js

@@ -1,4 +1,6 @@
 import * as R from "ramda";
+const mapToLowerCase = R.map(R.toLower);
+const hasAnyTruth = R.any(R.equals(true));
 const getType = (token) => (token.$type ?? token.type) || "";
 const getValue = (token) => token.$value ?? token.value;
 const typeEquals = R.curry((types, token) => {
@@ -7,8 +9,17 @@ const typeEquals = R.curry((types, token) => {
   }
   return R.includes(R.toLower(getType(token)), R.map(R.toLower, Array.isArray(types) ? types : [types]));
 });
+const pathStartsWithOneOf = R.curry((paths, token) => {
+  if (R.isNil(token)) {
+    return false;
+  }
+  const tokenPath = mapToLowerCase(token.path);
+  const matchPathsStartingWith = R.map((path) => R.startsWith([path], tokenPath), mapToLowerCase(paths));
+  return hasAnyTruth(matchPathsStartingWith);
+});
 export {
   getType,
   getValue,
+  pathStartsWithOneOf,
   typeEquals
 };

package/dist/types/bin/designsystemet.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=designsystemet.d.ts.map

package/dist/types/bin/designsystemet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designsystemet.d.ts","sourceRoot":"","sources":["../../../bin/designsystemet.ts"],"names":[],"mappings":""}

package/dist/types/src/colors/colorUtils.d.ts

@@ -0,0 +1,126 @@
+import type { CssColor } from '@adobe/leonardo-contrast-colors';
+/**
+ * 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
+ */
+export declare const hexToCssHsl: (hex: string, valuesOnly?: boolean) => string;
+/**
+ * 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
+ */
+export declare const hexToHSL: (H: string) => number[];
+/**
+ * Converts a HEX color '#xxxxxx' into an array of HSLuv values '[h,s,l]'
+ *
+ * @param hex A hex color string
+ * @returns
+ */
+export declare const hexToHsluv: (hex: string) => number[];
+/**
+ * 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
+ */
+export declare const hslArrToCss: (HSL: number[]) => string;
+/**
+ * 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
+ */
+export declare const HSLToHex: (h: number, s: number, l: number) => string;
+/**
+ * Converts a HEX color '#xxxxxx' into an array of RGB values '[R, G, B]'
+ *
+ * @param hex A hex color string
+ * @returns RGB values in an array
+ */
+export declare const hexToRgb: (hex: string) => {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+/**
+ * Get the luminance of an RGB color
+ *
+ * @param r RGB red value
+ * @param G RGB green value
+ * @param b RGB blue value
+ * @returns
+ */
+export declare const luminanceFromRgb: (r: string, g: string, b: string) => number;
+/**
+ * Get the luminance of a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */
+export declare const luminanceFromHex: (hex: CssColor) => number;
+/**
+ * Get the contrast ratio between two luminance values
+ *
+ * @param lum1 The first luminance value
+ * @param lum2 The second luminance value
+ * @returns
+ */
+export declare const getRatioFromLum: (lum1: number, lum2: number) => number;
+/**
+ * Get the HSL lightness from a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */
+export declare const getHslLightessFromHex: (hex: CssColor) => number;
+export declare const getHslSaturationFromHex: (hex: CssColor) => number;
+/**
+ * Get the HSLuv lightness from a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */
+export declare const getLightnessFromHex: (hex: string) => number;
+/**
+ * Get the contrast ratio between two HEX colors
+ *
+ * @param {CssColor} color1 The first color
+ * @param {CssColor} color2 The second color
+ * @returns
+ */
+export declare const getContrastFromHex: (color1: CssColor, color2: CssColor) => number;
+/**
+ * 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
+ */
+export declare const getContrastFromLightness: (lightness: number, mainColor: CssColor, backgroundColor: CssColor) => number;
+/**
+ * Maps the numbers from [start1 - end1] to the range [start2 - end2], maintaining the proportionality between the numbers in the ranges using lineaer interpolation.
+ */
+/**
+ * Check if two colors have enough contrast to be used together
+ *
+ * @param {CssColor} color1 The first color
+ * @param {CssColor} color2 The second color
+ * @returns {boolean} If the colors have enough contrast
+ */
+export declare const areColorsContrasting: (color1: CssColor, color2: CssColor, type?: "decorative" | "aa" | "aaa") => boolean;
+export declare const getApcaContrastLc: (textColor: CssColor, backgroundColor: CssColor) => string | number;
+/**
+ * Check if aa string value is a HEX color
+ *
+ * @param {string} hex The string to check
+ * @returns {boolean} If the string is a HEX color
+ */
+export declare const isHexColor: (hex: string) => boolean;
+//# sourceMappingURL=colorUtils.d.ts.map

package/dist/types/src/colors/colorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorUtils.d.ts","sourceRoot":"","sources":["../../../../src/colors/colorUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAKhE;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,iCA6CtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,MAAO,MAAM,aAwCjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,aAKrC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,EAAE,WAExC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,MAAO,MAAM,KAAK,MAAM,KAAK,MAAM,WA+CvD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,QAAS,MAAM;;;;QAYnC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,MAAO,MAAM,KAAK,MAAM,KAAK,MAAM,WAM/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAS,QAAQ,WAS7C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,SAAU,MAAM,QAAQ,MAAM,WAKzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAS,QAAQ,WAElD,CAAC;AAEF,eAAO,MAAM,uBAAuB,QAAS,QAAQ,WAEpD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAS,MAAM,WAK9C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,WAAY,QAAQ,UAAU,QAAQ,WAOpE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,cAAe,MAAM,aAAa,QAAQ,mBAAmB,QAAQ,WAYzG,CAAC;AAEF;;GAEG;AAKH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,WAAY,QAAQ,UAAU,QAAQ,SAAQ,YAAY,GAAG,IAAI,GAAG,KAAK,YAYzG,CAAC;AAEF,eAAO,MAAM,iBAAiB,cAAe,QAAQ,mBAAmB,QAAQ,oBAW/E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,YAErC,CAAC"}

package/dist/types/src/colors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './colorUtils';
+export * from './themeUtils';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/colors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}