@servicetitan/hammer-token 0.0.0-rc-20250807234739

package/build/web/core/semantic.scss

@@ -0,0 +1,137 @@
+$background-color: var(--background-color, #ffffff);
+$background-color-strong: var(--background-color-strong, #f7f7f7);
+$background-color-stronger: var(--background-color-stronger, #eeeeee);
+$background-color-strongest: var(--background-color-strongest, #bcbcbd);
+$background-color-primary: var(--background-color-primary, #0265DC);
+$background-color-primary-subdued: var(--background-color-primary-subdued, #E0F2FF);
+$background-color-success: var(--background-color-success, #007A4D);
+$background-color-success-subdued: var(--background-color-success-subdued, #CEF8E0);
+$background-color-danger: var(--background-color-danger, #e13212);
+$background-color-danger-subdued: var(--background-color-danger-subdued, #ffece9);
+$background-color-warning: var(--background-color-warning, #ffbe00);
+$background-color-disabled: var(--background-color-disabled, #606162);
+$background-color-inverted: var(--background-color-inverted, #2d2e31);
+$background-color-inverted-strong: var(--background-color-inverted-strong, #141414);
+$border-radius-none: 0;
+$border-radius-small: 0.1875rem;
+$border-radius-medium: 0.375rem;
+$border-radius-large: 0.75rem;
+$border-radius-xlarge: 1.5rem;
+$border-radius-circular: 100%;
+$border-width-none: 0rem;
+$border-width: 0.0625rem;
+$border-width-strong: 0.125rem;
+$border-color: var(--border-color, #949596);
+$border-color-subdued: var(--border-color-subdued, #dfe0e1);
+$border-color-strong: var(--border-color-strong, #444445);
+$border-color-primary: var(--border-color-primary, #0265DC);
+$border-color-success: var(--border-color-success, #007A4D);
+$border-color-danger: var(--border-color-danger, #e13212);
+$charts-monochrome-1: var(--charts-monochrome-1, #3892F3);
+$charts-monochrome-1-stroke: var(--charts-monochrome-1-stroke, transparent);
+$charts-monochrome-1-pattern: solid;
+$charts-monochrome-2: var(--charts-monochrome-2, #08389c);
+$charts-monochrome-2-stroke: var(--charts-monochrome-2-stroke, transparent);
+$charts-monochrome-2-pattern: solid;
+$charts-monochrome-3: var(--charts-monochrome-3, #F2F9FF);
+$charts-monochrome-3-stroke: var(--charts-monochrome-3-stroke, #3892F3);
+$charts-monochrome-3-pattern: striped;
+$charts-monochrome-4: var(--charts-monochrome-4, #F2F9FF);
+$charts-monochrome-4-stroke: var(--charts-monochrome-4-stroke, #3892F3);
+$charts-monochrome-4-pattern: solid;
+$charts-categorical-1: var(--charts-categorical-1, #3892F3);
+$charts-categorical-1-stroke: var(--charts-categorical-1-stroke, transparent);
+$charts-categorical-1-pattern: solid;
+$charts-categorical-2: var(--charts-categorical-2, #0FA2B8);
+$charts-categorical-2-stroke: var(--charts-categorical-2-stroke, transparent);
+$charts-categorical-2-pattern: solid;
+$charts-categorical-3: var(--charts-categorical-3, #907AF5);
+$charts-categorical-3-stroke: var(--charts-categorical-3-stroke, transparent);
+$charts-categorical-3-pattern: solid;
+$charts-categorical-4: var(--charts-categorical-4, #DE52CE);
+$charts-categorical-4-stroke: var(--charts-categorical-4-stroke, transparent);
+$charts-categorical-4-pattern: solid;
+$charts-categorical-5: var(--charts-categorical-5, #C2185B);
+$charts-categorical-5-stroke: var(--charts-categorical-5-stroke, transparent);
+$charts-categorical-5-pattern: solid;
+$charts-categorical-6: var(--charts-categorical-6, #759E15);
+$charts-categorical-6-stroke: var(--charts-categorical-6-stroke, transparent);
+$charts-categorical-6-pattern: solid;
+$charts-categorical-7: var(--charts-categorical-7, #AC6400);
+$charts-categorical-7-stroke: var(--charts-categorical-7-stroke, transparent);
+$charts-categorical-7-pattern: solid;
+$charts-categorical-8: var(--charts-categorical-8, #EB7200);
+$charts-categorical-8-stroke: var(--charts-categorical-8-stroke, transparent);
+$charts-categorical-8-pattern: solid;
+$charts-categorical-9: var(--charts-categorical-9, #D57A5C);
+$charts-categorical-9-stroke: var(--charts-categorical-9-stroke, transparent);
+$charts-categorical-9-pattern: solid;
+$charts-status-success: var(--charts-status-success, #007A4D);
+$charts-status-success-stroke: var(--charts-status-success-stroke, transparent);
+$charts-status-success-pattern: solid;
+$charts-status-warning: var(--charts-status-warning, #ffbe00);
+$charts-status-warning-stroke: var(--charts-status-warning-stroke, transparent);
+$charts-status-warning-pattern: solid;
+$charts-status-danger: var(--charts-status-danger, #e13212);
+$charts-status-danger-stroke: var(--charts-status-danger-stroke, transparent);
+$charts-status-danger-pattern: solid;
+$charts-status-neutral: var(--charts-status-neutral, #ffffff);
+$charts-status-neutral-stroke: var(--charts-status-neutral-stroke, #8C9CA5);
+$charts-status-neutral-pattern: striped;
+$focus-ring-color: var(--focus-ring-color, #0265DC);
+$focus-ring-color-danger: var(--focus-ring-color-danger, #e13212);
+$focus-ring-width: 0.25rem;
+$foreground-color: var(--foreground-color, #141414);
+$foreground-color-subdued: var(--foreground-color-subdued, #737475);
+$foreground-color-primary: var(--foreground-color-primary, #0265DC);
+$foreground-color-danger: var(--foreground-color-danger, #e13212);
+$foreground-color-inverted: var(--foreground-color-inverted, #ffffff);
+$foreground-color-on-primary: var(--foreground-color-on-primary, #ffffff);
+$foreground-color-on-danger: var(--foreground-color-on-danger, #ffffff);
+$foreground-color-on-danger-subdued: var(--foreground-color-on-danger-subdued, #bf2a00);
+$foreground-color-on-warning: var(--foreground-color-on-warning, #141414);
+$foreground-color-active-primary: var(--foreground-color-active-primary, #004491);
+$foreground-color-active-danger: var(--foreground-color-active-danger, #bf2a00);
+$foreground-color-hover-primary: var(--foreground-color-hover-primary, #004491);
+$foreground-color-hover-danger: var(--foreground-color-hover-danger, #bf2a00);
+$overlay-color-active: var(--overlay-color-active, #14141429);
+$overlay-color-active-primary: var(--overlay-color-active-primary, #0265DC4D);
+$overlay-color-active-danger: var(--overlay-color-active-danger, #e132124D);
+$overlay-color-active-on: var(--overlay-color-active-on, #14141429);
+$overlay-color-active-on-primary: var(--overlay-color-active-on-primary, #14141466);
+$overlay-color-active-on-danger: var(--overlay-color-active-on-danger, #14141466);
+$overlay-color-hover: var(--overlay-color-hover, #14141414);
+$overlay-color-hover-primary: var(--overlay-color-hover-primary, #0265DC1A);
+$overlay-color-hover-danger: var(--overlay-color-hover-danger, #e132121A);
+$overlay-color-hover-on: var(--overlay-color-hover-on, #14141414);
+$overlay-color-hover-on-primary: var(--overlay-color-hover-on-primary, #14141433);
+$overlay-color-hover-on-danger: var(--overlay-color-hover-on-danger, #14141433);
+$shadow-color: var(--shadow-color, #14141414);
+$shadow-size-flat: 0rem 0rem 0rem;
+$shadow-size-float: 0rem 0.125rem 0.5rem;
+$shadow-size-overlay: 0rem 0.5rem 1.5rem;
+$status-color-info: var(--status-color-info, #0265DC);
+$status-color-danger: var(--status-color-danger, #e13212);
+$status-color-success: var(--status-color-success, #007A4D);
+$status-color-warning: var(--status-color-warning, #ffbe00);
+$typography-paragraph-size-xsmall: 0.75rem;
+$typography-paragraph-size-small: 0.875rem;
+$typography-paragraph-size: 1rem;
+$typography-paragraph-size-large: 1.25rem;
+$typography-paragraph-size-xlarge: 1.5rem;
+$typography-paragraph-font-weight: 400;
+$typography-paragraph-font-family: var(--typography-paragraph-font-family, 'Nunito Sans', sans-serif);
+$typography-heading-size-xsmall: 0.875rem;
+$typography-heading-size-small: 1rem;
+$typography-heading-size: 1.25rem;
+$typography-heading-size-large: 1.5rem;
+$typography-heading-size-xlarge: 2rem;
+$typography-heading-font-weight: 700;
+$typography-heading-font-family: var(--typography-heading-font-family, 'Sofia Pro', SofiaPro, sans-serif);
+$typography-label-size-xsmall: 0.625rem;
+$typography-label-size-small: 0.75rem;
+$typography-label-size: 0.875rem;
+$typography-label-size-large: 1rem;
+$typography-label-size-xlarge: 1.25rem;
+$typography-label-font-weight: 600;
+$typography-label-font-family: var(--typography-label-font-family, 'Nunito Sans', sans-serif);

package/build/web/index.d.ts

@@ -0,0 +1,4 @@
+import Token from '../../type/types';
+declare const core: Token;
+export { Token }
+export { core }

package/build/web/index.js

@@ -0,0 +1,3 @@
+import * as core from './core';
+export * as Token from '../../type/types';
+export { core };

package/config.js

@@ -0,0 +1,504 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+const StyleDictionary = require("style-dictionary");
+const fs = require("fs-extra");
+const {
+  cssUtilsFormatter,
+  getVarValue,
+  generateBorderClasses,
+  generateColorClasses,
+  generateFontClasses,
+  generateSpacingClasses,
+} = require("./src/utils/css-utils-format-utils");
+
+StyleDictionary.registerFormat({
+  name: `custom/SCSSVariable`,
+  formatter: function ({ dictionary }) {
+    return dictionary.allTokens
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("-default", "")}`;
+        if (token.name.includes("font-family"))
+          return `$${name}: var(--${name}, ${value});`;
+        if (token.attributes.appearance) {
+          return `$${name}: var(--${name}, ${value});`;
+        }
+        return `$${name}: ${value};`;
+      })
+      .join(`\n`);
+  },
+});
+
+const nonColorTokens = [
+  "border-radius",
+  "font-family",
+  "font-weight",
+  "size",
+  "width",
+];
+
+StyleDictionary.registerFormat({
+  name: `custom/variables-map`,
+  formatter: function ({ dictionary }) {
+    const light = dictionary.allTokens
+      .filter((token) => {
+        let isColor = true;
+        nonColorTokens.forEach((t) => {
+          if (token.name.includes(t)) {
+            isColor = false;
+          }
+        });
+        return isColor;
+      })
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("-default", "")}`;
+        return `  ${name}: ${value},`;
+      })
+      .join(`\n`);
+
+    const dark = dictionary.allTokens
+      .filter((token) => {
+        let isColor = true;
+        nonColorTokens.forEach((t) => {
+          if (token.name.includes(t)) {
+            isColor = false;
+          }
+        });
+        return isColor;
+      })
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("-default", "")}`;
+        if (token.attributes.appearance) {
+          return `  ${name}: ${token.attributes.appearance.dark.value},`;
+        }
+        return `  ${name}: ${value},`;
+      })
+      .join(`\n`);
+
+    const nonColor = dictionary.allTokens
+      .filter((token) => {
+        let isColor = true;
+        nonColorTokens.forEach((t) => {
+          if (token.name.includes(t)) {
+            isColor = false;
+          }
+        });
+        return !isColor;
+      })
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("-default", "")}`;
+        if (token.name.includes("font-family")) return `  ${name}: "${value}",`;
+        return `  ${name}: ${value},`;
+      })
+      .join(`\n`);
+
+    return [
+      `$light: (`,
+      light,
+      `);`,
+      `$dark: (`,
+      dark,
+      `);`,
+      `$nonColor: (`,
+      nonColor,
+      `);`,
+    ].join(`\n`);
+  },
+});
+
+StyleDictionary.registerFormat({
+  name: `custom/primitive-variables`,
+  formatter: function ({ dictionary }) {
+    const vars = dictionary.allTokens
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("-default", "")}`;
+        if (token.name.includes("font-family")) return `  ${name}: "${value}",`;
+        return `  ${name}: ${value},`;
+      })
+      .join(`\n`);
+
+    return [`$token: (`, vars, `);`].join(`\n`);
+  },
+});
+
+StyleDictionary.registerFormat({
+  name: `custom/es6`,
+  formatter: function ({ dictionary }) {
+    const light = dictionary.allTokens
+      .filter((token) => !!token.attributes.appearance)
+      .map((token) => {
+        const value = JSON.stringify(token.value);
+        const name = token.name.replace("Default", "");
+        return `\t${name}: ${value}`;
+      })
+      .join(`,\n`);
+    const dark = dictionary.allTokens
+      .filter((token) => !!token.attributes.appearance)
+      .map((token) => {
+        const value = JSON.stringify(token.attributes.appearance.dark.value);
+        const name = token.name.replace("Default", "");
+        return `\t${name}: ${value}`;
+      })
+      .join(`,\n`);
+    const common = dictionary.allTokens
+      .filter((token) => !token.attributes.appearance)
+      .map((token) => {
+        const value = JSON.stringify(token.value);
+        const name = token.name.replace("Default", "");
+        return `\t${name}: ${value}`;
+      })
+      .join(`,\n`);
+    return `export const common = {\n${common}\n}\nexport const light = {\n${light}\n}\nexport const dark = {\n${dark}\n}\n`;
+  },
+});
+
+StyleDictionary.registerFormat({
+  name: `custom/es6Variable`,
+  formatter: function ({ dictionary }) {
+    return dictionary.allTokens
+      .map((token) => {
+        const value = token.value;
+        const name = `${token.name.replace("Default", "")}`;
+        if (token.attributes.appearance) {
+          return `export const ${name} = {
+  value: "${value}",
+  attributes: {
+    appearance: {
+      dark: {
+        value: "${token.attributes.appearance.dark.value}"
+      }
+    }
+  }
+};`;
+        }
+        return `export const ${name} = { value: "${value}" };`;
+      })
+      .join(`\n`);
+  },
+});
+
+const CSS_UTILS_PREFIXES = ["", "a2-"];
+
+for (const prefix of CSS_UTILS_PREFIXES) {
+  StyleDictionary.registerFormat({
+    name: `custom/CSSUtils/${prefix}All`,
+    formatter: function ({ dictionary }) {
+      const colorTokens = dictionary.allTokens
+        .map((token) => {
+          const value = getVarValue(dictionary, token);
+          const name = `${token.name.replace("Default", "")}`;
+
+          if (
+            // name.startsWith("color") || // primitives
+            name.startsWith("status-color") ||
+            name.startsWith("foreground-color") ||
+            name.startsWith("background-color") ||
+            name.startsWith("overlay-color")
+          ) {
+            const darkValue = getVarValue(dictionary, token, { isDark: true });
+            return generateColorClasses(name, value, { darkValue, prefix });
+          }
+          if (name.startsWith("border-color")) {
+            const darkValue = getVarValue(dictionary, token, { isDark: true });
+            return generateBorderClasses(name, value, { darkValue, prefix });
+          }
+          return null;
+        })
+        .flat()
+        .filter((t) => t != null)
+        .map((t) => `${t}`)
+        .sort((a, b) => a.localeCompare(b))
+        .join(`\n`);
+      const nonColorTokens = dictionary.allTokens
+        .map((token) => {
+          const value = getVarValue(dictionary, token);
+          const name = `${token.name.replace("Default", "")}`;
+
+          if (name.startsWith("border")) {
+            return generateBorderClasses(name, value, { prefix });
+          }
+          if (name.startsWith("typography")) {
+            return generateFontClasses(name, value, { prefix });
+          }
+          if (name.startsWith("size")) {
+            return generateSpacingClasses(name, value, { prefix });
+          }
+          return null;
+        })
+        .flat()
+        .filter((t) => t != null)
+        .map((t) => `${t}`)
+        .sort((a, b) => a.localeCompare(b))
+        .join(`\n`);
+
+      const colorFallbackTokens = dictionary.allTokens
+        .map((token) => {
+          const value = getVarValue(dictionary, token);
+          const name = `${token.name.replace("Default", "")}`;
+
+          if (
+            name.startsWith("status-color") ||
+            name.startsWith("foreground-color") ||
+            name.startsWith("background-color") ||
+            name.startsWith("overlay-color")
+          ) {
+            return generateColorClasses(name, value, { prefix });
+          }
+          if (name.startsWith("border-color")) {
+            return generateBorderClasses(name, value, { prefix });
+          }
+          return null;
+        })
+        .flat()
+        .filter((t) => t != null)
+        .map((t) => `${t}`)
+        .sort((a, b) => a.localeCompare(b))
+        .join(`\n`);
+
+      // Manually adding .sr-only
+      const withSr = nonColorTokens.concat(
+        "\n",
+        ".sr-only {border: 0; clip: rect(0, 0, 0, 0); height: 1px; margin: -1px; overflow: hidden; padding-block: 0; padding-inline: 0; position: absolute; white-space: nowrap; width: 1px;}",
+      );
+
+      return `@layer starter, reset, base, state, application;
+
+${withSr}
+${colorFallbackTokens}
+
+@supports (color: light-dark(#fff, #000)) {
+  ${colorTokens.replaceAll("\n", "\n  ")}
+}
+
+@layer application {
+    ${withSr.replaceAll("\n", "\n    ")}
+    ${colorFallbackTokens.replaceAll("\n", "\n    ")}
+    
+    @supports (color: light-dark(#fff, #000)) {
+      ${colorTokens.replaceAll("\n", "\n      ")}
+    }
+}`;
+    },
+  });
+
+  StyleDictionary.registerFormat({
+    name: `custom/CSSUtils/${prefix}Borders`,
+    formatter: function ({ dictionary }) {
+      return cssUtilsFormatter(dictionary, generateBorderClasses, {
+        hasDark: true,
+        prefix,
+      });
+    },
+  });
+
+  StyleDictionary.registerFormat({
+    name: `custom/CSSUtils/${prefix}Colors`,
+    formatter: function ({ dictionary }) {
+      return cssUtilsFormatter(dictionary, generateColorClasses, {
+        hasDark: true,
+        prefix,
+      });
+    },
+  });
+
+  StyleDictionary.registerFormat({
+    name: `custom/CSSUtils/${prefix}Fonts`,
+    formatter: function ({ dictionary }) {
+      return cssUtilsFormatter(dictionary, generateFontClasses, { prefix });
+    },
+  });
+
+  StyleDictionary.registerFormat({
+    name: `custom/CSSUtils/${prefix}Spacing`,
+    formatter: function ({ dictionary }) {
+      return cssUtilsFormatter(dictionary, generateSpacingClasses, { prefix });
+    },
+  });
+}
+
+const getDirectories = (source) =>
+  fs
+    .readdirSync(source, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+const themes = getDirectories(`src/theme`);
+
+themes.forEach((theme) => {
+  StyleDictionary.extend({
+    source: [`src/theme/${theme}/*.js`, `src/theme/${theme}/component/*.js`],
+    include: ["src/global/primitive/*.js"],
+    platforms: {
+      css: {
+        transformGroup: "css",
+        buildPath: `build/web/${theme}/css-utils/`,
+        files: CSS_UTILS_PREFIXES.flatMap((prefix) => [
+          {
+            destination: `${prefix}utils.css`,
+            format: `custom/CSSUtils/${prefix}All`,
+          },
+          {
+            destination: `${prefix}border.css`,
+            format: `custom/CSSUtils/${prefix}Borders`,
+            filter: function (token) {
+              return token.filePath.includes("border");
+            },
+          },
+          {
+            destination: `${prefix}color.css`,
+            format: `custom/CSSUtils/${prefix}Colors`,
+            filter: function (token) {
+              return (
+                token.filePath.includes("primitive/color") ||
+                token.name.includes("color")
+              );
+            },
+          },
+          {
+            destination: `${prefix}font.css`,
+            format: `custom/CSSUtils/${prefix}Fonts`,
+            filter: function (token) {
+              return (
+                token.filePath.includes("primitive/font") ||
+                token.filePath.includes("typography")
+              );
+            },
+          },
+          {
+            destination: `${prefix}spacing.css`,
+            format: `custom/CSSUtils/${prefix}Spacing`,
+            filter: function (token) {
+              return token.filePath.startsWith("src/global/primitive/size");
+            },
+          },
+        ]),
+      },
+      scss: {
+        transformGroup: "scss",
+        buildPath: `build/web/${theme}/`,
+        files: [
+          {
+            destination: "primitive.scss",
+            format: "custom/SCSSVariable",
+            filter: function (token) {
+              return token.filePath.startsWith("src/global/primitive");
+            },
+          },
+          {
+            destination: "primitive-variables.scss",
+            format: "custom/primitive-variables",
+            filter: function (token) {
+              return token.filePath.startsWith("src/global/primitive");
+            },
+          },
+          {
+            destination: "semantic.scss",
+            format: "custom/SCSSVariable",
+            filter: function (token) {
+              return (
+                token.filePath.startsWith(`src/theme/${theme}`) &&
+                !token.filePath.startsWith(`src/theme/${theme}/component`)
+              );
+            },
+          },
+          {
+            destination: "semantic-variables.scss",
+            format: "custom/variables-map",
+            filter: function (token) {
+              return (
+                token.filePath.startsWith(`src/theme/${theme}`) &&
+                !token.filePath.startsWith(`src/theme/${theme}/component`)
+              );
+            },
+          },
+          {
+            destination: "component.scss",
+            format: "custom/SCSSVariable",
+            filter: function (token) {
+              return token.filePath.startsWith(`src/theme/${theme}/component`);
+            },
+          },
+          {
+            destination: "component-variables.scss",
+            format: "custom/variables-map",
+            filter: function (token) {
+              return token.filePath.startsWith(`src/theme/${theme}/component`);
+            },
+          },
+        ],
+      },
+      tsLight: {
+        transformGroup: "js",
+        buildPath: `build/web/${theme}/`,
+        files: [
+          {
+            format: "custom/es6Variable",
+            destination: "primitive.js",
+            filter: function (token) {
+              return token.filePath.startsWith("src/global/primitive");
+            },
+          },
+          {
+            format: "custom/es6",
+            destination: "raw.js",
+            filter: function (token) {
+              return (
+                token.filePath.startsWith(`src/theme/${theme}`) &&
+                !token.filePath.startsWith(`src/theme/${theme}/component`)
+              );
+            },
+          },
+          {
+            format: "custom/es6Variable",
+            destination: "semantic.js",
+            filter: function (token) {
+              return (
+                token.filePath.startsWith(`src/theme/${theme}`) &&
+                !token.filePath.startsWith(`src/theme/${theme}/component`)
+              );
+            },
+          },
+          {
+            format: "custom/es6Variable",
+            destination: "component.js",
+            filter: function (token) {
+              return token.filePath.startsWith(`src/theme/${theme}/component`);
+            },
+          },
+        ],
+      },
+    },
+  }).buildAllPlatforms();
+});
+
+console.log("\n==============================================");
+console.log("Building index files...\n");
+const mainJS = fs.createWriteStream(`build/web/index.js`);
+
+const mainType = fs.createWriteStream(`build/web/index.d.ts`);
+mainType.write(`import Token from '../../type/types';\n`);
+
+themes.forEach((theme) => {
+  const indexJS = fs.createWriteStream(`build/web/${theme}/index.js`);
+  indexJS.write(`import * as semantic from './semantic';\n`);
+  indexJS.write(`import * as primitive from './primitive';\n`);
+  indexJS.write(`import * as component from './component';\n`);
+  indexJS.write(`const name = '${theme}';\n`);
+  indexJS.write(`export { primitive, semantic, component, name };\n`);
+  indexJS.end();
+  mainType.write(`declare const ${theme}: Token;\n`);
+  mainJS.write(`import * as ${theme} from './${theme}';\n`);
+});
+
+mainType.write(`export { Token }\n`);
+mainType.write(`export { ${themes.join(", ")} }\n`);
+mainType.end();
+
+mainJS.write(`export * as Token from '../../type/types';\n`);
+mainJS.write(`export { ${themes.join(", ")} };\n`);
+mainJS.end();
+console.log(`Index built!`);
+console.log("==============================================\n");

package/eslint.config.mjs

@@ -0,0 +1,4 @@
+import baseConfig from "../../eslint.base.config.mjs";
+import eslintConfigPrettier from "eslint-config-prettier/flat";
+
+export default [...baseConfig, eslintConfigPrettier];

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@servicetitan/hammer-token",
+  "version": "0.0.0-rc-20250807234739",
+  "description": "",
+  "main": "build/web/index.js",
+  "types": "build/web/index.d.ts",
+  "bin": {
+    "hammer-token": "./src/utils/copy-css-utils-cli.js"
+  },
+  "optionalDependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "fs-extra": "^11.2.0",
+    "style-dictionary": "^3",
+    "tinycolor2": "^1.6.0"
+  },
+  "scripts": {
+    "build": "node ./config.js",
+    "dev": "pnpm build && chokidar \"./src\" -c \"pnpm build\"",
+    "clean": "rimraf build .turbo",
+    "lint": "eslint .",
+    "nuke": "pnpm clean && rimraf node_modules"
+  }
+}