@tamagui/theme-builder 1.79.9 → 1.79.11

package/src/buildThemeSuiteScales.ts

@@ -2,73 +2,46 @@ import { hsla, parseToHsla, toHex } from 'color2k'
 
 import { BuildTheme, ScaleTypeName } from './types'
 
-export function getColorForegroundBackground(color: string, isDarkMode = false) {
-  const [h, s, l] = parseToHsla(color)
-  const isColorLight = l > 0.5
-  const oppositeLightness = l > 0.5 ? 1 - l : 0.5 + l
-  const oppositeLightnessColor = toHex(hsla(h, s, oppositeLightness, 1))
-  const foreground = isDarkMode ? color : oppositeLightnessColor
-  const background = foreground === color ? oppositeLightnessColor : color
-  return {
-    foreground,
-    foregroundLightness: foreground === color ? l : oppositeLightness,
-    background,
-    backgroundLightness: foreground !== color ? l : oppositeLightness,
-  }
-}
-
-export const getThemeSuiteScale = (theme: BuildTheme, accent?: boolean): ScaleType => {
-  const baseColor = accent ? theme.accent || theme.color : theme.color
-  const scale = accent ? theme.accentScale || theme.scale : theme.scale
-
-  let base = scaleTypes[scale]
-
-  if (!baseColor) {
-    return base
-  }
-
-  const [h, s, l] = parseToHsla(baseColor)
-
-  if (scale === 'automatic') {
-    const lightColors = getColorForegroundBackground(baseColor, false)
-    const darkColors = getColorForegroundBackground(baseColor, true)
-
-    const scaleLen = 12
-    const arr = new Array(scaleLen).fill(0)
-
-    function getScale(bgL: number, fgL: number) {
-      const stepSize = (fgL - bgL) / scaleLen
-      return arr.map((_, i) => bgL + i * stepSize)
-    }
-
-    return {
-      ...base,
-      lumScale: {
-        light: getScale(lightColors.backgroundLightness, lightColors.foregroundLightness),
-        dark: getScale(darkColors.backgroundLightness, darkColors.foregroundLightness),
-      },
-    }
-  }
-
-  return {
-    ...base,
-    lumScale: {
-      light: adjustScale(theme, base.lumScale.light, l, true),
-      dark: adjustScale(theme, base.lumScale.dark, 1 - l),
-    },
-    ...(base.satScale && {
-      satScale: {
-        light: adjustScale(theme, base.satScale.light, s, true),
-        dark: adjustScale(theme, base.satScale.dark, s),
-      },
-    }),
-  }
-}
+// export function getColorForegroundBackground(color: string, isDarkMode = false) {
+//   const [h, s, l] = parseToHsla(color)
+//   const isColorLight = l > 0.5
+//   const oppositeLightness = l > 0.5 ? 1 - l : 0.5 + l
+//   const oppositeLightnessColor = toHex(hsla(h, s, oppositeLightness, 1))
+//   const foreground = isDarkMode ? color : oppositeLightnessColor
+//   const background = foreground === color ? oppositeLightnessColor : color
+//   return {
+//     foreground,
+//     foregroundLightness: foreground === color ? l : oppositeLightness,
+//     background,
+//     backgroundLightness: foreground !== color ? l : oppositeLightness,
+//   }
+// }
+
+// if (scale === 'automatic') {
+//   const lightColors = getColorForegroundBackground(baseColor, false)
+//   const darkColors = getColorForegroundBackground(baseColor, true)
+
+//   const scaleLen = 12
+//   const arr = new Array(scaleLen).fill(0)
+
+//   function getScale(bgL: number, fgL: number) {
+//     const stepSize = (fgL - bgL) / scaleLen
+//     return arr.map((_, i) => bgL + i * stepSize)
+//   }
+
+//   return {
+//     ...base,
+//     lumScale: {
+//       light: getScale(lightColors.backgroundLightness, lightColors.foregroundLightness),
+//       dark: getScale(darkColors.backgroundLightness, darkColors.foregroundLightness),
+//     },
+//   }
+// }
 
 export type ScaleType<A extends ScaleTypeName = ScaleTypeName> = {
   name: string
   createdFrom?: A // we copy the scale values - keeping this helps us refer back to the scale. also helpful if we change scales in the future
-  lumScale: {
+  lumScale?: {
     light: Array<number>
     dark: Array<number>
   }
@@ -78,15 +51,23 @@ export type ScaleType<A extends ScaleTypeName = ScaleTypeName> = {
   }
 }
 
-export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
-  automatic: {
-    createdFrom: 'automatic',
-    name: 'Automatic',
-    lumScale: {
-      light: [],
-      dark: [],
-    },
+export function getScalePreset<Name extends ScaleTypeName>(
+  a: Name
+): (typeof scaleTypes)[Name] {
+  return scaleTypes[a]
+}
+
+const fullSatScale = {
+  light: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+  dark: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+}
+
+export const scaleTypes = {
+  custom: {
+    name: 'Custom',
+    createdFrom: 'custom',
   },
+
   radix: {
     name: 'Radius',
     createdFrom: 'radix',
@@ -115,6 +96,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
         0.11, 0.136, 0.158, 0.179, 0.205, 0.243, 0.313, 0.439, 0.47, 0.52, 0.56, 0.61,
       ],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   'radius-bright': {
@@ -124,6 +109,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       light: [1, 0.954, 0.94, 0.9, 0.85, 0.804, 0.747, 0.659, 0.541, 0.453, 0.27, 0.086],
       dark: [0, 0.1, 0.16, 0.2, 0.24, 0.36, 0.42, 0.46, 0.5, 0.54, 0.84, 0.97],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   'radius-bold': {
@@ -133,6 +122,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       light: [1, 0.9, 0.885, 0.82, 0.77, 0.54, 0.32, 0.25, 0.16, 0.12, 0.075, 0],
       dark: [0, 0.13, 0.2, 0.24, 0.3, 0.34, 0.45, 0.55, 0.65, 0.885, 0.9, 1],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   linear: {
@@ -142,6 +135,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       light: [1, 0.925, 0.9, 0.85, 0.75, 0.6, 0.4, 0.3, 0.25, 0.15, 0.125, 0],
       dark: [0, 0.075, 0.125, 0.15, 0.25, 0.4, 0.6, 0.75, 0.85, 0.9, 0.925, 1],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   neon: {
@@ -155,6 +152,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
         0.07, 0.11, 0.136, 0.158, 0.179, 0.205, 0.243, 0.313, 0.439, 0.52, 0.61, 0.93,
       ],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   'neon-bright': {
@@ -164,6 +165,10 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       light: [0.45, 0.475, 0.5, 0.525, 0.55, 0.575, 0.6, 0.625, 0.65, 0.2, 0.1, 0],
       dark: [0.45, 0.475, 0.5, 0.525, 0.55, 0.575, 0.6, 0.625, 0.65, 0.2, 0.1, 0],
     },
+    satScale: {
+      light: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+      dark: [0.65, 0.55, 0.4, 0.4, 0.35, 0.35, 0.35, 0.35, 0.4, 0.4, 0.3, 0.2],
+    },
   },
 
   'neon-c': {
@@ -173,10 +178,7 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       light: [0.45, 0.475, 0.5, 0.525, 0.55, 0.575, 0.6, 0.625, 0.65, 0.2, 0.1, 0],
       dark: [0.45, 0.475, 0.5, 0.525, 0.55, 0.575, 0.6, 0.625, 0.65, 0.2, 0.1, 0],
     },
-    satScale: {
-      light: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-      dark: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-    },
+    satScale: fullSatScale,
   },
 
   pastel: {
@@ -208,7 +210,7 @@ export const scaleTypes: Record<ScaleTypeName, ScaleType> = {
       dark: [0.6, 0.5, 0.4, 0.35, 0.3, 0.3, 0.3, 0.3, 0.4, 0.35, 0.25, 0.15],
     },
   },
-}
+} satisfies Record<ScaleTypeName, ScaleType>
 
 const adjustScale = (
   theme: BuildTheme,

package/src/masks.ts

@@ -0,0 +1,147 @@
+import {
+  MaskDefinitions,
+  MaskOptions,
+  combineMasks,
+  createIdentityMask,
+  createInverseMask,
+  createMask,
+  createSoftenMask,
+  createStrengthenMask,
+  skipMask,
+} from '@tamagui/create-theme'
+
+const shadows = {
+  shadowColor: 0,
+  shadowColorHover: 0,
+  shadowColorPress: 0,
+  shadowColorFocus: 0,
+}
+
+const colors = {
+  ...shadows,
+  color: 0,
+  colorHover: 0,
+  colorFocus: 0,
+  colorPress: 0,
+}
+
+const templateColorsSpecific = {
+  color1: 1,
+  color2: 2,
+  color3: 3,
+  color4: 4,
+  color5: 5,
+  color6: 6,
+  color7: 7,
+  color8: 8,
+  color9: 9,
+  color10: 10,
+  color11: 11,
+  color12: 12,
+}
+
+const skipShadowsAndSpecificColors = {
+  ...shadows,
+  ...templateColorsSpecific,
+}
+
+const PALETTE_LEN = 14
+
+const baseMaskOptions: MaskOptions = {
+  override: shadows,
+  skip: shadows,
+  // avoids the transparent ends
+  max: PALETTE_LEN - 2,
+  min: 1,
+}
+
+export const maskOptions = {
+  component: {
+    ...baseMaskOptions,
+    override: colors,
+    skip: skipShadowsAndSpecificColors,
+  },
+  alt: {
+    ...baseMaskOptions,
+  },
+  button: {
+    ...baseMaskOptions,
+    override: {
+      ...colors,
+      borderColor: 'transparent',
+      borderColorHover: 'transparent',
+    },
+    skip: skipShadowsAndSpecificColors,
+  },
+} satisfies Record<string, MaskOptions>
+
+export const masks = {
+  identity: createIdentityMask(),
+  soften: createSoftenMask(),
+  soften2: createSoftenMask({ strength: 2 }),
+  soften3: createSoftenMask({ strength: 3 }),
+  strengthen: createStrengthenMask(),
+  inverse: createInverseMask(),
+  inverseSoften: combineMasks(createInverseMask(), createSoftenMask({ strength: 2 })),
+  inverseSoften2: combineMasks(createInverseMask(), createSoftenMask({ strength: 3 })),
+  inverseSoften3: combineMasks(createInverseMask(), createSoftenMask({ strength: 4 })),
+  inverseStrengthen2: combineMasks(
+    createInverseMask(),
+    createStrengthenMask({ strength: 2 })
+  ),
+  strengthenButSoftenBorder: createMask((template, options) => {
+    const stronger = createStrengthenMask().mask(template, options)
+    const softer = createSoftenMask().mask(template, options)
+    return {
+      ...stronger,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus,
+    }
+  }),
+  soften2Border1: createMask((template, options) => {
+    const softer2 = createSoftenMask({ strength: 2 }).mask(template, options)
+    const softer1 = createSoftenMask({ strength: 1 }).mask(template, options)
+    return {
+      ...softer2,
+      borderColor: softer1.borderColor,
+      borderColorHover: softer1.borderColorHover,
+      borderColorPress: softer1.borderColorPress,
+      borderColorFocus: softer1.borderColorFocus,
+    }
+  }),
+  soften3FlatBorder: createMask((template, options) => {
+    const borderMask = createSoftenMask({ strength: 2 }).mask(template, options)
+    const softer3 = createSoftenMask({ strength: 3 }).mask(template, options)
+    return {
+      ...softer3,
+      borderColor: borderMask.borderColor,
+      borderColorHover: borderMask.borderColorHover,
+      borderColorPress: borderMask.borderColorPress,
+      borderColorFocus: borderMask.borderColorFocus,
+    }
+  }),
+  softenBorder: createMask((template, options) => {
+    const plain = skipMask.mask(template, options)
+    const softer = createSoftenMask().mask(template, options)
+    return {
+      ...plain,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus,
+    }
+  }),
+  softenBorder2: createMask((template, options) => {
+    const plain = skipMask.mask(template, options)
+    const softer = createSoftenMask({ strength: 2 }).mask(template, options)
+    return {
+      ...plain,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus,
+    }
+  }),
+} satisfies MaskDefinitions

package/src/types.ts

@@ -21,7 +21,7 @@ export type BuildThemeSuitePalettes = {
 }
 
 export type ScaleTypeName =
-  | 'automatic'
+  | 'custom'
   | 'radix'
   | 'radix-b'
   | 'radius-bold'
@@ -39,13 +39,32 @@ export type BuildThemeBase = {
   errors?: string[]
 }
 
+export type BuildThemeAnchor = {
+  index: number
+  hue: {
+    light: number
+    dark: number
+  }
+  sat: {
+    light: number
+    dark: number
+  }
+  lum: {
+    light: number
+    dark: number
+  }
+}
+
 export type BuildTheme = BuildThemeBase & {
   type: 'theme'
-  color: string
+
   scale: ScaleTypeName
+
+  anchors: BuildThemeAnchor[]
+
   template?: Template
-  accent?: string
-  accentScale?: ScaleTypeName
+
+  accent?: BuildTheme
 }
 
 // TODO type here isnt the same as type in BuildTheme

package/types/buildThemeSuite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildThemeSuite.d.ts","sourceRoot":"","sources":["../src/buildThemeSuite.ts"],"names":[],"mappings":"AAWA,OAAO,EAAkB,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAE9D,wBAAgB,eAAe,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuW7E;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"buildThemeSuite.d.ts","sourceRoot":"","sources":["../src/buildThemeSuite.ts"],"names":[],"mappings":"AAWA,OAAO,EAAkB,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAiB9D,wBAAgB,eAAe,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8W7E;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/types/buildThemeSuitePalettes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildThemeSuitePalettes.d.ts","sourceRoot":"","sources":["../src/buildThemeSuitePalettes.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAgF7D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,uBAAuB,CAOhF"}
+{"version":3,"file":"buildThemeSuitePalettes.d.ts","sourceRoot":"","sources":["../src/buildThemeSuitePalettes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAoB,uBAAuB,EAAE,MAAM,SAAS,CAAA;AA0J/E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,uBAAuB,CAOhF"}

package/types/buildThemeSuiteScales.d.ts

@@ -1,15 +1,8 @@
-import { BuildTheme, ScaleTypeName } from './types';
-export declare function getColorForegroundBackground(color: string, isDarkMode?: boolean): {
-    foreground: string;
-    foregroundLightness: number;
-    background: string;
-    backgroundLightness: number;
-};
-export declare const getThemeSuiteScale: (theme: BuildTheme, accent?: boolean) => ScaleType;
+import { ScaleTypeName } from './types';
 export type ScaleType<A extends ScaleTypeName = ScaleTypeName> = {
     name: string;
     createdFrom?: A;
-    lumScale: {
+    lumScale?: {
         light: Array<number>;
         dark: Array<number>;
     };
@@ -18,5 +11,131 @@ export type ScaleType<A extends ScaleTypeName = ScaleTypeName> = {
         dark: Array<number>;
     };
 };
-export declare const scaleTypes: Record<ScaleTypeName, ScaleType>;
+export declare function getScalePreset<Name extends ScaleTypeName>(a: Name): (typeof scaleTypes)[Name];
+export declare const scaleTypes: {
+    custom: {
+        name: string;
+        createdFrom: "custom";
+    };
+    radix: {
+        name: string;
+        createdFrom: "radix";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'radix-b': {
+        name: string;
+        createdFrom: "radix-b";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'radius-bright': {
+        name: string;
+        createdFrom: "radius-bright";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'radius-bold': {
+        name: string;
+        createdFrom: "radius-bold";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    linear: {
+        name: string;
+        createdFrom: "linear";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    neon: {
+        name: string;
+        createdFrom: "neon";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'neon-bright': {
+        name: string;
+        createdFrom: "neon-bright";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'neon-c': {
+        name: string;
+        createdFrom: "neon-c";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    pastel: {
+        name: string;
+        createdFrom: "pastel";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+    'pastel-desaturating': {
+        name: string;
+        createdFrom: "pastel-desaturating";
+        lumScale: {
+            light: number[];
+            dark: number[];
+        };
+        satScale: {
+            light: number[];
+            dark: number[];
+        };
+    };
+};
 //# sourceMappingURL=buildThemeSuiteScales.d.ts.map

package/types/buildThemeSuiteScales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildThemeSuiteScales.d.ts","sourceRoot":"","sources":["../src/buildThemeSuiteScales.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEnD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,UAAQ;;;;;EAa7E;AAED,eAAO,MAAM,kBAAkB,UAAW,UAAU,WAAW,OAAO,KAAG,SA8CxE,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,IAAI;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,QAAQ,EAAE;QACR,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACpB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KACpB,CAAA;IACD,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACpB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KACpB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,aAAa,EAAE,SAAS,CAkIvD,CAAA"}
+{"version":3,"file":"buildThemeSuiteScales.d.ts","sourceRoot":"","sources":["../src/buildThemeSuiteScales.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,aAAa,EAAE,MAAM,SAAS,CAAA;AAsCnD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,IAAI;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACpB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KACpB,CAAA;IACD,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACpB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KACpB,CAAA;CACF,CAAA;AAED,wBAAgB,cAAc,CAAC,IAAI,SAAS,aAAa,EACvD,CAAC,EAAE,IAAI,GACN,CAAC,OAAO,UAAU,CAAC,CAAC,IAAI,CAAC,CAE3B;AAOD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoJqB,CAAA"}

package/types/masks.d.ts

@@ -0,0 +1,110 @@
+export declare const maskOptions: {
+    component: {
+        override: {
+            color: number;
+            colorHover: number;
+            colorFocus: number;
+            colorPress: number;
+            shadowColor: number;
+            shadowColorHover: number;
+            shadowColorPress: number;
+            shadowColorFocus: number;
+        };
+        skip: {
+            color1: number;
+            color2: number;
+            color3: number;
+            color4: number;
+            color5: number;
+            color6: number;
+            color7: number;
+            color8: number;
+            color9: number;
+            color10: number;
+            color11: number;
+            color12: number;
+            shadowColor: number;
+            shadowColorHover: number;
+            shadowColorPress: number;
+            shadowColorFocus: number;
+        };
+        palette?: import("@tamagui/create-theme").CreateThemePalette | undefined;
+        overrideStrategy?: "shift" | "swap" | undefined;
+        overrideSwap?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        overrideShift?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        strength?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        parentName?: string | undefined;
+    };
+    alt: {
+        palette?: import("@tamagui/create-theme").CreateThemePalette | undefined;
+        override?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        overrideStrategy?: "shift" | "swap" | undefined;
+        overrideSwap?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        overrideShift?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        skip?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        strength?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        parentName?: string | undefined;
+    };
+    button: {
+        override: {
+            borderColor: string;
+            borderColorHover: string;
+            color: number;
+            colorHover: number;
+            colorFocus: number;
+            colorPress: number;
+            shadowColor: number;
+            shadowColorHover: number;
+            shadowColorPress: number;
+            shadowColorFocus: number;
+        };
+        skip: {
+            color1: number;
+            color2: number;
+            color3: number;
+            color4: number;
+            color5: number;
+            color6: number;
+            color7: number;
+            color8: number;
+            color9: number;
+            color10: number;
+            color11: number;
+            color12: number;
+            shadowColor: number;
+            shadowColorHover: number;
+            shadowColorPress: number;
+            shadowColorFocus: number;
+        };
+        palette?: import("@tamagui/create-theme").CreateThemePalette | undefined;
+        overrideStrategy?: "shift" | "swap" | undefined;
+        overrideSwap?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        overrideShift?: Partial<import("@tamagui/create-theme").ThemeMask> | undefined;
+        strength?: number | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        parentName?: string | undefined;
+    };
+};
+export declare const masks: {
+    identity: import("@tamagui/create-theme").CreateMask;
+    soften: import("@tamagui/create-theme").CreateMask;
+    soften2: import("@tamagui/create-theme").CreateMask;
+    soften3: import("@tamagui/create-theme").CreateMask;
+    strengthen: import("@tamagui/create-theme").CreateMask;
+    inverse: import("@tamagui/create-theme").CreateMask;
+    inverseSoften: import("@tamagui/create-theme").CreateMask;
+    inverseSoften2: import("@tamagui/create-theme").CreateMask;
+    inverseSoften3: import("@tamagui/create-theme").CreateMask;
+    inverseStrengthen2: import("@tamagui/create-theme").CreateMask;
+    strengthenButSoftenBorder: import("@tamagui/create-theme").CreateMask;
+    soften2Border1: import("@tamagui/create-theme").CreateMask;
+    soften3FlatBorder: import("@tamagui/create-theme").CreateMask;
+    softenBorder: import("@tamagui/create-theme").CreateMask;
+    softenBorder2: import("@tamagui/create-theme").CreateMask;
+};
+//# sourceMappingURL=masks.d.ts.map