@digdir/designsystemet 1.0.2 → 1.0.4

package/dist/bin/config.js

@@ -1,71 +0,0 @@
-import * as R from "ramda";
-import { z } from "zod";
-import { convertToHex } from "../src/colors/index.js";
-import { RESERVED_COLORS } from "../src/colors/theme.js";
-import { cliOptions } from "../src/tokens/create.js";
-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;
-}
-const hexPatterns = [
-  // Hex colors: #000, #0000, #000000, #00000000
-  `#[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({
-  description: `A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`
-}).regex(colorRegex).transform(convertToHex);
-const colorCategorySchema = z.record(
-  z.string().regex(new RegExp(reservedColorsPattern, "i"), {
-    message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
-  }),
-  colorSchema,
-  {
-    description: "One or more color definitions",
-    invalid_type_error: "Color definitions must be hex color values"
-  }
-).refine((colors) => !Object.keys(colors).some((key) => RESERVED_COLORS.includes(key.toLowerCase())), {
-  message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
-});
-const themeSchema = z.object(
-  {
-    colors: z.object(
-      {
-        main: colorCategorySchema,
-        support: colorCategorySchema.optional().default({}),
-        neutral: colorSchema
-      },
-      { description: "Defines the colors for this theme" }
-    ),
-    typography: z.object(
-      {
-        fontFamily: z.string({ description: "Sets the font-family for this theme" })
-      },
-      { description: "Defines the typography for a given theme" }
-    ).optional(),
-    borderRadius: z.number({ description: "Defines the border-radius for this theme" }).optional()
-  },
-  { description: "An object defining a theme. The property name holding the object becomes the theme name." }
-);
-const configFileSchema = z.object({
-  outDir: z.string({ description: "Path to the output directory for the created design tokens" }).optional(),
-  clean: z.boolean({ description: "Delete the output directory before building or creating tokens" }).optional(),
-  themes: z.record(themeSchema, {
-    description: "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name."
-  })
-});
-const combinedConfigSchema = configFileSchema.required();
-export {
-  colorRegex,
-  combinedConfigSchema,
-  configFileSchema,
-  mapPathToOptionName
-};

package/dist/src/migrations/codemods/jsx/classname-prefix.d.ts

@@ -1,10 +0,0 @@
-import type { API, FileInfo } from 'jscodeshift';
-/**
- * Replace all class prefixes from 'fds-' to 'ds-'
- * @param file
- * @param api
- * @returns
- */
-declare function replaceClassNamePrefix(file: FileInfo, api: API): string | undefined;
-export default replaceClassNamePrefix;
-//# sourceMappingURL=classname-prefix.d.ts.map

package/dist/src/migrations/codemods/jsx/classname-prefix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"classname-prefix.d.ts","sourceRoot":"","sources":["../../../../../src/migrations/codemods/jsx/classname-prefix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAmB,MAAM,aAAa,CAAC;AAoElE;;;;;GAKG;AACH,iBAAS,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAiB5E;AAED,eAAe,sBAAsB,CAAC"}

package/dist/src/migrations/codemods/jsx/classname-prefix.js

@@ -1,64 +0,0 @@
-const replaceInLiteral = (node) => {
-  if (node.startsWith("fds-")) {
-    return node.replace("fds-", "ds-");
-  }
-  return node;
-};
-const replaceInTemplateLiteral = (node) => {
-  for (const element of node) {
-    const value = element.value.raw;
-    if (typeof value !== "string") continue;
-    element.value.raw = replaceInLiteral(value);
-  }
-};
-const processNode = (node) => {
-  if (!node) return;
-  if (node.type === "Literal") {
-    const value = node.value;
-    if (typeof value !== "string") return;
-    node.value = replaceInLiteral(value);
-  } else if (node.type === "StringLiteral") {
-    const value = node.value;
-    if (typeof value !== "string") return;
-    node.value = replaceInLiteral(value);
-  } else if (node.type === "TemplateLiteral") {
-    node.quasis && replaceInTemplateLiteral(node.quasis);
-  } else if (node.type === "JSXExpressionContainer") {
-    const expression = node.expression;
-    if (!expression) return;
-    if (expression.type === "CallExpression") {
-      expression.arguments?.forEach(processNode);
-    } else {
-      processNode(expression);
-    }
-  } else if (node.type === "ConditionalExpression") {
-    node.test && processNode(node.test);
-    node.consequent && processNode(node.consequent);
-    node.alternate && processNode(node.alternate);
-  } else if (node.type === "BinaryExpression") {
-    node.right && processNode(node.right);
-    node.left && processNode(node.left);
-  } else if (node.type === "LogicalExpression") {
-    node.right && processNode(node.right);
-    node.left && processNode(node.left);
-  }
-};
-function replaceClassNamePrefix(file, api) {
-  const j = api.jscodeshift;
-  const root = j(file.source);
-  for (const path of root.find(j.JSXElement).paths()) {
-    const nodes = j(path).find(j.JSXAttribute, { name: { name: "className" } });
-    for (const nodePath of nodes.paths()) {
-      processNode(nodePath.value.value);
-    }
-  }
-  return root.toSource({
-    quote: "single",
-    reuseWhitespace: true,
-    wrapColumn: 100
-  });
-}
-var classname_prefix_default = replaceClassNamePrefix;
-export {
-  classname_prefix_default as default
-};

package/dist/src/migrations/codemods/jsx/run.d.ts

@@ -1,7 +0,0 @@
-type CssCodemodProps = {
-    globPattern?: string;
-    dry?: boolean;
-};
-export declare const runJSXCodemod: ({ globPattern, dry }: CssCodemodProps) => Promise<void>;
-export {};
-//# sourceMappingURL=run.d.ts.map

package/dist/src/migrations/codemods/jsx/run.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../../src/migrations/codemods/jsx/run.ts"],"names":[],"mappings":"AAKA,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAIF,eAAO,MAAM,aAAa,GAAU,sBAAqC,eAAe,kBAiBvF,CAAC"}

package/dist/src/migrations/codemods/jsx/run.js

@@ -1,22 +0,0 @@
-import chalk from "chalk";
-import glob from "fast-glob";
-import { run as jscodeshift } from "jscodeshift/src/Runner.js";
-const transformer = `${import.meta.dirname}/classname-prefix.ts`;
-const runJSXCodemod = async ({ globPattern = "./**/*.tsx", dry }) => {
-  const options = {
-    dry,
-    extensions: "tsx",
-    parser: "tsx"
-  };
-  const transform = async () => {
-    const files = await glob(globPattern, { ignore: ["node_modules/**", "dist/**"] });
-    const result = await jscodeshift(transformer, files, options);
-    if (result.ok) {
-      console.log(chalk.green("Finished parsing"));
-    }
-  };
-  return transform();
-};
-export {
-  runJSXCodemod
-};

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

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

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

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

package/dist/src/migrations/react-beta-to-v1.js

@@ -1,5 +0,0 @@
-import { runJSXCodemod } from "./codemods/jsx/run.js";
-var react_beta_to_v1_default = (glob) => runJSXCodemod({ globPattern: glob });
-export {
-  react_beta_to_v1_default as default
-};

package/dist/src/scripts/copy-internal-tokens.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=copy-internal-tokens.d.ts.map

package/dist/src/scripts/copy-internal-tokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy-internal-tokens.d.ts","sourceRoot":"","sources":["../../../src/scripts/copy-internal-tokens.ts"],"names":[],"mappings":""}

package/dist/src/scripts/copy-internal-tokens.js

@@ -1,28 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-const DIRNAME = import.meta.dirname || __dirname;
-const TARGET = path.join(DIRNAME, "../../../../design-tokens");
-const INTERNAL = path.join(DIRNAME, "../../internal/design-tokens");
-async function copyFiles() {
-  console.log("\u{1F4C1} Copying design tokens");
-  await fs.cp(
-    path.join(INTERNAL, "primitives/modes/color-scheme"),
-    path.join(TARGET, "primitives/modes/color-scheme"),
-    { recursive: true }
-  );
-  await fs.cp(path.join(INTERNAL, "primitives/modes/size"), path.join(TARGET, "primitives/modes/size"), {
-    recursive: true
-  });
-  await fs.cp(
-    path.join(INTERNAL, "primitives/modes/typography/size"),
-    path.join(TARGET, "primitives/modes/typography/size"),
-    {
-      recursive: true
-    }
-  );
-  await fs.cp(path.join(INTERNAL, "primitives/globals.json"), path.join(TARGET, "primitives/globals.json"));
-  await fs.cp(path.join(INTERNAL, "semantic"), path.join(TARGET, "semantic"), { recursive: true });
-  await fs.cp(path.join(INTERNAL, "themes"), path.join(TARGET, "themes"), { recursive: true });
-  console.log("\u2705 Finished copying design tokens");
-}
-copyFiles();

package/dist/src/tokens/build/configs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../../../src/tokens/build/configs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,IAAI,qBAAqB,EAAoB,MAAM,wBAAwB,CAAC;AAQhG,OAAO,KAAK,EAGV,kBAAkB,EAClB,2BAA2B,EAC3B,cAAc,EACd,gBAAgB,EACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,oBAAoB,EAA6B,MAAM,sCAAsC,CAAC;AAO5G,eAAO,MAAM,MAAM,OAAO,CAAC;AAC3B,eAAO,MAAM,cAAc,KAAK,CAAC;AA8BjC,MAAM,MAAM,wBAAwB,GAAG,CACrC,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,KACE,qBAAqB,GAAG;IAAE,MAAM,EAAE,qBAAqB,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAAE,EAAE,CAAC;AA2OnH,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYnB,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,WAAW,wBAAwB,EACnC,QAAQ,oBAAoB,EAAE,EAC9B,YAAY,cAAc,EAAE,EAC5B,SAAS,kBAAkB,KAC1B,2BAA2B,EA8B7B,CAAC"}

package/dist/src/tokens/build/configs.js

@@ -1,280 +0,0 @@
-import { expandTypesMap, register } from "@tokens-studio/sd-transforms";
-import * as R from "ramda";
-import StyleDictionary from "style-dictionary";
-import { outputReferencesFilter } from "style-dictionary/utils";
-import { buildOptions } from "../build.js";
-import { isColorCategoryToken, isDigit, isSemanticColorToken, pathStartsWithOneOf, typeEquals } from "../utils.js";
-import { formats } from "./formats/css.js";
-import { jsTokens } from "./formats/js-tokens.js";
-import { resolveMath, sizeRem, typographyName, unitless } from "./transformers.js";
-import { getMultidimensionalThemes } from "./utils/getMultidimensionalThemes.js";
-void register(StyleDictionary, { withSDBuiltins: false });
-const usesDtcg = true;
-const prefix = "ds";
-const basePxFontSize = 16;
-const fileHeader = () => [`These files are generated from design tokens defind using Token Studio`];
-StyleDictionary.registerTransform(sizeRem);
-StyleDictionary.registerTransform(typographyName);
-StyleDictionary.registerTransform(resolveMath);
-StyleDictionary.registerTransform(unitless);
-StyleDictionary.registerFormat(jsTokens);
-for (const format of Object.values(formats)) {
-  StyleDictionary.registerFormat(format);
-}
-const dsTransformers = [
-  "name/kebab",
-  resolveMath.name,
-  "ts/size/px",
-  sizeRem.name,
-  unitless.name,
-  "ts/typography/fontWeight",
-  typographyName.name,
-  "ts/color/modifiers",
-  "ts/color/css/hexrgba",
-  "ts/size/lineheight",
-  "shadow/css/shorthand"
-];
-const paritionPrimitives = R.partition(R.test(/(?!.*global\.json).*primitives.*/));
-const colorSchemeVariables = ({ "color-scheme": colorScheme = "light", theme }, { outPath }) => {
-  const selector = `${colorScheme === "light" ? ":root, " : ""}[data-color-scheme="${colorScheme}"]`;
-  const layer = `ds.theme.color-scheme.${colorScheme}`;
-  return {
-    usesDtcg,
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        outPath,
-        colorScheme,
-        theme,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${outPath}/${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `color-scheme/${colorScheme}.css`,
-            format: formats.colorScheme.name,
-            filter: (token) => !token.isSource && typeEquals("color", token) && !R.startsWith(["global"], token.path)
-          }
-        ],
-        options: {
-          fileHeader,
-          outputReferences: false
-        }
-      }
-    }
-  };
-};
-const colorCategoryVariables = (opts) => ({ "color-scheme": colorScheme, theme, ...permutation }, { outPath }) => {
-  const category = opts.category;
-  const color = category === "builtin" ? opts.color : permutation[`${category}-color`];
-  if (!color) {
-    throw new Error(
-      category === "builtin" ? `Missing color for built-in color ${opts.color}` : `Missing color for category ${category}`
-    );
-  }
-  const layer = `ds.theme.color`;
-  const isRootColor = color === buildOptions?.rootColor;
-  const selector = `${isRootColor ? ":root, [data-color-scheme], " : ""}[data-color="${color}"]`;
-  const config = {
-    usesDtcg,
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        outPath,
-        colorScheme,
-        theme,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${outPath}/${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `color/${color}.css`,
-            format: formats.colorCategory.name,
-            filter: (token) => category === "builtin" ? isSemanticColorToken(token, color) : isColorCategoryToken(token, category)
-          }
-        ],
-        options: {
-          fileHeader,
-          outputReferences: true
-        }
-      }
-    }
-  };
-  return config;
-};
-const semanticVariables = ({ theme }, { outPath }) => {
-  const selector = `:root`;
-  const layer = `ds.theme.semantic`;
-  return {
-    usesDtcg,
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        outPath,
-        theme,
-        basePxFontSize,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${outPath}/${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `semantic.css`,
-            format: formats.semantic.name,
-            filter: (token) => {
-              const unwantedPaths = pathStartsWithOneOf(["font-size", "line-height", "letter-spacing"], token);
-              const unwantedTypes = typeEquals(["color", "fontWeight", "fontFamily", "typography"], token);
-              const unwantedTokens = !(unwantedPaths || unwantedTypes);
-              return !token.isSource && unwantedTokens;
-            }
-          }
-        ],
-        options: {
-          fileHeader,
-          outputReferences: (token, options) => {
-            const include = pathStartsWithOneOf(["border-radius"], token);
-            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && isDigit(token.path[1]);
-            return (include || isWantedSize) && outputReferencesFilter(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-const typescriptTokens = ({ "color-scheme": colorScheme, theme }, { outPath }) => {
-  return {
-    usesDtcg,
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      ts: {
-        prefix,
-        basePxFontSize,
-        transforms: dsTransformers,
-        buildPath: `${outPath}/${theme}/`,
-        files: [
-          {
-            destination: `${colorScheme}.ts`,
-            format: jsTokens.name,
-            filter: (token) => {
-              if (pathStartsWithOneOf(["border-width", "letter-spacing", "border-radius"], token) && !R.includes("semantic", token.filePath))
-                return false;
-              const isSemanticColor = R.includes("semantic", token.filePath) && typeEquals(["color"], token);
-              const wantedTypes = typeEquals(["shadow", "dimension", "typography", "opacity"], token);
-              return isSemanticColor || wantedTypes;
-            }
-          }
-        ],
-        options: {
-          fileHeader,
-          outputReferences: (token, options) => {
-            const include = pathStartsWithOneOf(["border-radius"], token);
-            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && isDigit(token.path[1]);
-            return (include || isWantedSize) && outputReferencesFilter(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-const typographyVariables = ({ theme, typography }, { outPath }) => {
-  const selector = `${typography === "primary" ? ":root, " : ""}[data-typography="${typography}"]`;
-  const layer = `ds.theme.typography.${typography}`;
-  return {
-    usesDtcg: true,
-    preprocessors: ["tokens-studio"],
-    expand: {
-      include: ["typography"],
-      typesMap: { ...expandTypesMap, typography: { ...expandTypesMap.typography, letterSpacing: "dimension" } }
-    },
-    platforms: {
-      css: {
-        prefix,
-        typography,
-        selector,
-        layer,
-        buildPath: `${outPath}/${theme}/`,
-        basePxFontSize,
-        transforms: [
-          "name/kebab",
-          "ts/size/px",
-          sizeRem.name,
-          "ts/size/lineheight",
-          "ts/typography/fontWeight",
-          typographyName.name
-        ],
-        files: [
-          {
-            destination: `typography/${typography}.css`,
-            format: formats.typography.name,
-            filter: (token) => {
-              const included = typeEquals(
-                ["typography", "fontweight", "fontFamily", "lineHeight", "dimension", "font", "fontsize"],
-                token
-              );
-              if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
-              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "_size", "border-width", "border-radius"], token);
-            }
-          }
-        ],
-        options: {
-          fileHeader
-        }
-      }
-    }
-  };
-};
-const configs = {
-  colorSchemeVariables,
-  mainColorVariables: colorCategoryVariables({ category: "main" }),
-  supportColorVariables: colorCategoryVariables({ category: "support" }),
-  neutralColorVariables: colorCategoryVariables({ category: "builtin", color: "neutral" }),
-  successColorVariables: colorCategoryVariables({ category: "builtin", color: "success" }),
-  dangerColorVariables: colorCategoryVariables({ category: "builtin", color: "danger" }),
-  warningColorVariables: colorCategoryVariables({ category: "builtin", color: "warning" }),
-  infoColorVariables: colorCategoryVariables({ category: "builtin", color: "info" }),
-  typographyVariables,
-  semanticVariables,
-  typescriptTokens
-};
-const getConfigsForThemeDimensions = (getConfig, themes, dimensions, options) => {
-  const { outPath, tokensDir } = options;
-  const permutations = getMultidimensionalThemes(themes, dimensions);
-  return permutations.flatMap(({ selectedTokenSets, permutation }) => {
-    const setsWithPaths = selectedTokenSets.map((x) => `${tokensDir}/${x}.json`);
-    const [source, include] = paritionPrimitives(setsWithPaths);
-    const configOrConfigs = getConfig(permutation, { outPath });
-    const configs_ = Array.isArray(configOrConfigs) ? configOrConfigs : [{ config: configOrConfigs }];
-    const configs2 = configs_.map(({ config, permutationOverrides }) => {
-      return {
-        permutation: { ...permutation, ...permutationOverrides },
-        config: {
-          ...config,
-          log: {
-            ...config?.log,
-            verbosity: buildOptions?.verbose ? "verbose" : "silent"
-          },
-          source,
-          include
-        }
-      };
-    });
-    return configs2;
-  }).sort();
-};
-export {
-  basePxFontSize,
-  configs,
-  getConfigsForThemeDimensions,
-  prefix
-};

package/dist/src/tokens/build/formats/css.d.ts

@@ -1,53 +0,0 @@
-import type { TransformedToken } from 'style-dictionary';
-import type { Format } from 'style-dictionary/types';
-/**
- * In the given tokens array, inline and remove tokens that match the predicate
- *
- * Example: In pseudo-code, given the predicate `(token) => token.path === ['size', '1']` and the following tokens
- * ```js
- *  [
- *    { path: ['size', 'base'], original: { $value: '8px' } },
- *    { path: ['size', '1'], original: { $value: '{size.base} * 2' } },
- *    { path: ['size', 'sm']: original: { $value: 'min({size.1}, 12px)' } }
- *  ]
- * ```
- * would return
- * ```js
- *  [
- *    { path: ['size', 'base'], original: { $value: '8px' } },
- *    { path: ['size', 'sm']: original: { $value: 'min({size.base} * 2, 12px)' } }
- *  ]
- * ```
- *
- * @param shouldSquash - predicate to determine if token should be inlined
- * @param tokens - array of tokens to transform
- * @returns copy of `tokens` without those that matched the predicate,
- *          where references to the matching tokens have been inlined
- */
-export declare function squashTokens(shouldSquash: (t: TransformedToken) => boolean, tokens: TransformedToken[]): import("style-dictionary/types").TransformedToken[];
-declare module 'style-dictionary/types' {
-    interface LocalOptions {
-        replaceCategoryWith?: string;
-    }
-}
-export declare const isNumericSizeToken: (t: TransformedToken) => boolean;
-export declare const isSquashTokens: (t: TransformedToken) => boolean;
-/**
- * Overrides the default sizing formula with a custom one that supports [round()](https://developer.mozilla.org/en-US/docs/Web/CSS/round) if supported.
- *
- * @param format - Function to format a token into a CSS property string.
- * @param tokens - Array of transformed tokens to format.
- * @returns Object with formatted CSS strings for calc and round.
- */
-export declare const overrideSizingFormula: (format: (t: TransformedToken) => string, token: TransformedToken) => {
-    name: string;
-    round: string;
-    calc: string;
-};
-export declare const formats: {
-    colorScheme: Format;
-    colorCategory: Format;
-    semantic: Format;
-    typography: Format;
-};
-//# sourceMappingURL=css.d.ts.map

package/dist/src/tokens/build/formats/css.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/build/formats/css.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAarD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,gBAAgB,KAAK,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,uDAetG;AAsDD,OAAO,QAAQ,wBAAwB,CAAC;IACtC,UAAiB,YAAY;QAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;CACF;AAsCD,eAAO,MAAM,kBAAkB,GAAI,GAAG,gBAAgB,YAA4D,CAAC;AAEnH,eAAO,MAAM,cAAc,MAHY,gBAAgB,YAGkC,CAAC;AAE1F;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,CAAC,CAAC,EAAE,gBAAgB,KAAK,MAAM,EAAE,OAAO,gBAAgB;;;;CAYrG,CAAC;AA4FF,eAAO,MAAM,OAAO;;;;;CAKc,CAAC"}

package/dist/src/tokens/build/formats/js-tokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-tokens.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/build/formats/js-tokens.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAoB,MAAM,wBAAwB,CAAC;AAoBvE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MAuCtB,CAAC"}

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

@@ -1,48 +0,0 @@
-import * as R from "ramda";
-import { createPropertyFormatter, fileHeader } from "style-dictionary/utils";
-import { getType, isColorCategoryToken, pathStartsWithOneOf } from "../../utils.js";
-import { isSquashTokens, overrideSizingFormula, squashTokens } from "./css.js";
-const groupByType = R.groupBy((token) => getType(token));
-const removeUnwatedTokens = R.pipe(
-  R.reject((token) => isColorCategoryToken(token)),
-  R.reject((token) => R.any((path) => path.startsWith("_"))(token.path))
-);
-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, options }) => {
-    const { usesDtcg, outputReferences } = options;
-    const format = createPropertyFormatter({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const formatTokens = R.map((token) => {
-      if (pathStartsWithOneOf(["size", "_size"], token)) {
-        const { calc, name } = overrideSizingFormula(format, token);
-        return {
-          ...token,
-          name: name.trim(),
-          $value: calc.trim()
-        };
-      }
-      return {
-        ...token,
-        name: toCssVarName(format(token))
-      };
-    });
-    const processTokens = R.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
-    const tokens = processTokens(squashTokens(isSquashTokens, dictionary.allTokens));
-    const content = Object.entries(tokens).map(
-      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
-`
-    ).join("\n");
-    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
-  }
-};
-export {
-  jsTokens
-};

package/dist/src/tokens/build/transformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../../../../src/tokens/build/transformers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAMxD,eAAO,MAAM,OAAO,EAAE,SAyBrB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAS5B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,SAWzB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,SAMtB,CAAC"}