@animus-ui/theming 0.1.1-beta.25 → 0.1.1-beta.26

package/CHANGELOG.md

@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.1.1-beta.26](https://github.com/codecaaron/animus/compare/@animus-ui/theming@0.1.1-beta.25...@animus-ui/theming@0.1.1-beta.26) (2025-05-29)
+
+**Note:** Version bump only for package @animus-ui/theming
+
 ## [0.1.1-beta.25](https://github.com/codecaaron/animus/compare/@animus-ui/theming@0.1.1-beta.24...@animus-ui/theming@0.1.1-beta.25) (2023-03-15)
 
 **Note:** Version bump only for package @animus-ui/theming

package/dist/core/ThemeBuilder.d.ts

@@ -1,34 +1,34 @@
-import { Breakpoints } from '@animus-ui/core';
-/**
- * 1. Breakpoints
- * 2. Scales
- * 3. Tokens
- * 4. Variables
- * 5. Colors
- * 6. Color Modes
- */
-export declare class ThemeWithAll<Bps, Scales, Tokens, Vars> {
-    breakpoints: Bps;
-    scales: Scales;
-    tokens: Tokens;
-    variables: Vars;
-    constructor(breakpoints: Bps, scales: Scales, tokens: Tokens, vars: Vars);
-    addScale(): ThemeWithAll<Bps, Scales, Tokens, Vars>;
-    build(): {
-        breakpoints: Bps;
-    } & Scales & {
-        _tokens: Tokens;
-        _variables: Vars;
-    };
-}
-export declare class ThemeWithRawColors<Bps extends Breakpoints, Scales, Tokens, Vars> extends ThemeWithAll<Bps, Scales, Tokens, Vars> {
-    constructor(breakpoints: Bps, scales: Scales, tokens: Tokens, vars: Vars);
-    addColorModes(): ThemeWithAll<Bps, Scales, Tokens, Vars>;
-}
-export declare class ThemeWithBreakpoints<Bps extends Breakpoints> extends ThemeWithAll<Bps, {}, {}, {}> {
-    constructor(breakpoints: Bps);
-    addColors(): ThemeWithRawColors<Bps, {}, {}, {}>;
-}
-export declare class ThemeUnitialized {
-    addBreakpoints<Bps extends Breakpoints>(breakpoints: Bps): ThemeWithBreakpoints<Bps>;
-}
+import { Breakpoints } from '@animus-ui/core';
+/**
+ * 1. Breakpoints
+ * 2. Scales
+ * 3. Tokens
+ * 4. Variables
+ * 5. Colors
+ * 6. Color Modes
+ */
+export declare class ThemeWithAll<Bps, Scales, Tokens, Vars> {
+    breakpoints: Bps;
+    scales: Scales;
+    tokens: Tokens;
+    variables: Vars;
+    constructor(breakpoints: Bps, scales: Scales, tokens: Tokens, vars: Vars);
+    addScale(): ThemeWithAll<Bps, Scales, Tokens, Vars>;
+    build(): {
+        breakpoints: Bps;
+    } & Scales & {
+        _tokens: Tokens;
+        _variables: Vars;
+    };
+}
+export declare class ThemeWithRawColors<Bps extends Breakpoints, Scales, Tokens, Vars> extends ThemeWithAll<Bps, Scales, Tokens, Vars> {
+    constructor(breakpoints: Bps, scales: Scales, tokens: Tokens, vars: Vars);
+    addColorModes(): ThemeWithAll<Bps, Scales, Tokens, Vars>;
+}
+export declare class ThemeWithBreakpoints<Bps extends Breakpoints> extends ThemeWithAll<Bps, {}, {}, {}> {
+    constructor(breakpoints: Bps);
+    addColors(): ThemeWithRawColors<Bps, {}, {}, {}>;
+}
+export declare class ThemeUnitialized {
+    addBreakpoints<Bps extends Breakpoints>(breakpoints: Bps): ThemeWithBreakpoints<Bps>;
+}

package/dist/index.d.ts

@@ -1 +1 @@
-export * from './utils';
+export * from './utils';

package/dist/index.js

@@ -1,142 +1,111 @@
 import { isObject, merge, mapValues } from 'lodash';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-  return keys;
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
 }
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
+function _checkPrivateRedeclaration(e, t) {
+  if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
 }
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
-  }
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
 }
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
+function _classPrivateFieldInitSpec(e, t, a) {
+  _checkPrivateRedeclaration(e, t), t.set(e, a);
 }
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
   }
-  return obj;
 }
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-  return target;
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
 }
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return target;
+  return t;
 }
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return (hint === "string" ? String : Number)(input);
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+  return e;
 }
-function _classPrivateFieldGet(receiver, privateMap) {
-  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
-  return _classApplyDescriptorGet(receiver, descriptor);
-}
-function _classPrivateFieldSet(receiver, privateMap, value) {
-  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
-  _classApplyDescriptorSet(receiver, descriptor, value);
-  return value;
-}
-function _classExtractFieldDescriptor(receiver, privateMap, action) {
-  if (!privateMap.has(receiver)) {
-    throw new TypeError("attempted to " + action + " private field on non-instance");
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
-  return privateMap.get(receiver);
+  return i;
 }
-function _classApplyDescriptorGet(receiver, descriptor) {
-  if (descriptor.get) {
-    return descriptor.get.call(receiver);
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
   }
-  return descriptor.value;
+  return t;
 }
-function _classApplyDescriptorSet(receiver, descriptor, value) {
-  if (descriptor.set) {
-    descriptor.set.call(receiver, value);
-  } else {
-    if (!descriptor.writable) {
-      throw new TypeError("attempted to set read only private field");
-    }
-    descriptor.value = value;
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
 }
-function _checkPrivateRedeclaration(obj, privateCollection) {
-  if (privateCollection.has(obj)) {
-    throw new TypeError("Cannot initialize the same private elements twice on an object");
+function _classApplyDescriptorGet(e, t) {
+  return t.get ? t.get.call(e) : t.value;
+}
+function _classApplyDescriptorSet(e, t, l) {
+  if (t.set) t.set.call(e, l);else {
+    if (!t.writable) throw new TypeError("attempted to set read only private field");
+    t.value = l;
   }
 }
-function _classPrivateFieldInitSpec(obj, privateMap, value) {
-  _checkPrivateRedeclaration(obj, privateMap);
-  privateMap.set(obj, value);
+function _classPrivateFieldGet(e, t) {
+  var r = _classPrivateFieldGet2(t, e);
+  return _classApplyDescriptorGet(e, r);
+}
+function _classPrivateFieldSet(e, t, r) {
+  var s = _classPrivateFieldGet2(t, e);
+  return _classApplyDescriptorSet(e, s, r), r;
 }
 
 function flattenScale(object, path) {
@@ -192,10 +161,10 @@ var ThemeBuilder = /*#__PURE__*/function () {
     });
     _classPrivateFieldSet(this, _theme, baseTheme);
   }
-  /**
-   *
-   * @param key A key of the current theme to transform into CSS Variables and Variable References
-   * @example .createScaleVariables('fontSize')
+  /**
+   *
+   * @param key A key of the current theme to transform into CSS Variables and Variable References
+   * @example .createScaleVariables('fontSize')
    */
   _createClass(ThemeBuilder, [{
     key: "createScaleVariables",
@@ -207,10 +176,10 @@ var ThemeBuilder = /*#__PURE__*/function () {
       _classPrivateFieldSet(this, _theme, merge({}, _classPrivateFieldGet(this, _theme), (_merge = {}, _defineProperty(_merge, key, tokens), _defineProperty(_merge, "_variables", _defineProperty({}, key, variables)), _defineProperty(_merge, "_tokens", _defineProperty({}, key, _classPrivateFieldGet(this, _theme)[key])), _merge)));
       return this;
     }
-    /**
-     *
-     * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
-     * @example .addColors({ navy: 'navy', hyper: 'purple' })
+    /**
+     *
+     * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
+     * @example .addColors({ navy: 'navy', hyper: 'purple' })
      */
   }, {
     key: "addColors",
@@ -230,11 +199,11 @@ var ThemeBuilder = /*#__PURE__*/function () {
       }));
       return this;
     }
-    /**
-     *
-     * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
-     * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
-     * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
+    /**
+     *
+     * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
+     * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
+     * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
      */
   }, {
     key: "addColorModes",
@@ -269,11 +238,11 @@ var ThemeBuilder = /*#__PURE__*/function () {
       }));
       return this;
     }
-    /**
-     *
-     * @param key A new key of theme
-     * @param createScale A function that accepts the current theme and returns a new object of scale values.
-     * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
+    /**
+     *
+     * @param key A new key of theme
+     * @param createScale A function that accepts the current theme and returns a new object of scale values.
+     * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
      */
   }, {
     key: "addScale",
@@ -281,11 +250,11 @@ var ThemeBuilder = /*#__PURE__*/function () {
       _classPrivateFieldSet(this, _theme, merge({}, _classPrivateFieldGet(this, _theme), _defineProperty({}, key, flattenScale(createScale(_classPrivateFieldGet(this, _theme))))));
       return this;
     }
-    /**
-     *
-     * @param key A current key of theme to be updated with new or computed values
-     * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
-     * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
+    /**
+     *
+     * @param key A current key of theme to be updated with new or computed values
+     * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
+     * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
      */
   }, {
     key: "updateScale",
@@ -293,8 +262,8 @@ var ThemeBuilder = /*#__PURE__*/function () {
       _classPrivateFieldSet(this, _theme, merge({}, _classPrivateFieldGet(this, _theme), _defineProperty({}, key, updateFn(_classPrivateFieldGet(this, _theme)[key]))));
       return this;
     }
-    /**
-     * This finalizes the theme build and returns the final theme and variables to be provided.
+    /**
+     * This finalizes the theme build and returns the final theme and variables to be provided.
      */
   }, {
     key: "build",

package/dist/utils/createTheme.d.ts

@@ -1,53 +1,53 @@
-import { AbstractTheme, CSSObject } from '@animus-ui/core';
-import { LiteralPaths } from './flattenScale';
-import { KeyAsVariable } from './serializeTokens';
-import { ColorModeConfig, Merge, MergeTheme, PrivateThemeKeys } from './types';
-export declare class ThemeBuilder<T extends AbstractTheme> {
-    #private;
-    constructor(baseTheme: T);
-    /**
-     *
-     * @param key A key of the current theme to transform into CSS Variables and Variable References
-     * @example .createScaleVariables('fontSize')
-     */
-    createScaleVariables<Key extends keyof Omit<T, 'breakpoints'> & string>(key: Key): ThemeBuilder<MergeTheme<T, PrivateThemeKeys, Record<Key, Record<Key, KeyAsVariable<T[Key], Key>>>>>;
-    /**
-     *
-     * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
-     * @example .addColors({ navy: 'navy', hyper: 'purple' })
-     */
-    addColors<Colors extends Record<string, string | number | CSSObject>, NextColors extends LiteralPaths<Colors, '-'>>(colors: Colors): ThemeBuilder<MergeTheme<T & PrivateThemeKeys, Record<'colors', KeyAsVariable<NextColors, 'color'>>>>;
-    /**
-     *
-     * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
-     * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
-     * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
-     */
-    addColorModes<Modes extends string, InitialMode extends keyof Config, Colors extends keyof T['colors'], ModeColors extends ColorModeConfig<Colors>, Config extends Record<Modes, ModeColors>, ColorAliases extends {
-        [K in keyof Config]: LiteralPaths<Config[K], '-', '_'>;
-    }>(initialMode: InitialMode, modeConfig: Config): ThemeBuilder<MergeTheme<T & PrivateThemeKeys, {
-        colors: KeyAsVariable<LiteralPaths<Config[keyof Config], '-', '_'>, 'colors'> & T['colors'];
-        modes: Merge<T['modes'], ColorAliases>;
-        mode: keyof Config;
-        _getColorValue: (color: keyof T['colors']) => string;
-    }>>;
-    /**
-     *
-     * @param key A new key of theme
-     * @param createScale A function that accepts the current theme and returns a new object of scale values.
-     * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
-     */
-    addScale<Key extends string, Fn extends (theme: T) => Record<string | number, string | number | Record<string, string | number>>, NewScale extends LiteralPaths<ReturnType<Fn>, '-'>>(key: Key, createScale: Fn): ThemeBuilder<MergeTheme<T, Record<Key, NewScale>>>;
-    /**
-     *
-     * @param key A current key of theme to be updated with new or computed values
-     * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
-     * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
-     */
-    updateScale<Key extends keyof T, Fn extends (tokens: T[Key]) => Record<string | number, unknown>>(key: Key, updateFn: Fn): ThemeBuilder<T & Record<Key, T[Key] & ReturnType<Fn>>>;
-    /**
-     * This finalizes the theme build and returns the final theme and variables to be provided.
-     */
-    build(): T & PrivateThemeKeys;
-}
-export declare function createTheme<T extends AbstractTheme>(base: T): ThemeBuilder<T>;
+import { AbstractTheme, CSSObject } from '@animus-ui/core';
+import { LiteralPaths } from './flattenScale';
+import { KeyAsVariable } from './serializeTokens';
+import { ColorModeConfig, Merge, MergeTheme, PrivateThemeKeys } from './types';
+export declare class ThemeBuilder<T extends AbstractTheme> {
+    #private;
+    constructor(baseTheme: T);
+    /**
+     *
+     * @param key A key of the current theme to transform into CSS Variables and Variable References
+     * @example .createScaleVariables('fontSize')
+     */
+    createScaleVariables<Key extends keyof Omit<T, 'breakpoints'> & string>(key: Key): ThemeBuilder<MergeTheme<T, PrivateThemeKeys, Record<Key, Record<Key, KeyAsVariable<T[Key], Key>>>>>;
+    /**
+     *
+     * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
+     * @example .addColors({ navy: 'navy', hyper: 'purple' })
+     */
+    addColors<Colors extends Record<string, string | number | CSSObject>, NextColors extends LiteralPaths<Colors, '-'>>(colors: Colors): ThemeBuilder<MergeTheme<T & PrivateThemeKeys, Record<'colors', KeyAsVariable<NextColors, 'color'>>>>;
+    /**
+     *
+     * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
+     * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
+     * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
+     */
+    addColorModes<Modes extends string, InitialMode extends keyof Config, Colors extends keyof T['colors'], ModeColors extends ColorModeConfig<Colors>, Config extends Record<Modes, ModeColors>, ColorAliases extends {
+        [K in keyof Config]: LiteralPaths<Config[K], '-', '_'>;
+    }>(initialMode: InitialMode, modeConfig: Config): ThemeBuilder<MergeTheme<T & PrivateThemeKeys, {
+        colors: KeyAsVariable<LiteralPaths<Config[keyof Config], '-', '_'>, 'colors'> & T['colors'];
+        modes: Merge<T['modes'], ColorAliases>;
+        mode: keyof Config;
+        _getColorValue: (color: keyof T['colors']) => string;
+    }>>;
+    /**
+     *
+     * @param key A new key of theme
+     * @param createScale A function that accepts the current theme and returns a new object of scale values.
+     * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
+     */
+    addScale<Key extends string, Fn extends (theme: T) => Record<string | number, string | number | Record<string, string | number>>, NewScale extends LiteralPaths<ReturnType<Fn>, '-'>>(key: Key, createScale: Fn): ThemeBuilder<MergeTheme<T, Record<Key, NewScale>>>;
+    /**
+     *
+     * @param key A current key of theme to be updated with new or computed values
+     * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
+     * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
+     */
+    updateScale<Key extends keyof T, Fn extends (tokens: T[Key]) => Record<string | number, unknown>>(key: Key, updateFn: Fn): ThemeBuilder<T & Record<Key, T[Key] & ReturnType<Fn>>>;
+    /**
+     * This finalizes the theme build and returns the final theme and variables to be provided.
+     */
+    build(): T & PrivateThemeKeys;
+}
+export declare function createTheme<T extends AbstractTheme>(base: T): ThemeBuilder<T>;

package/dist/utils/flattenScale.d.ts

@@ -1,20 +1,20 @@
-/**
- * Returns an exhaustive list of all possible paths of an object T for keys K.
- * Possibilities are returned as `k1.k2.k3`.
- */
-export type FindPath<T, K extends keyof T, D extends string = '.'> = K extends string | number ? T[K] extends Record<string | number, any> ? T[K] extends ArrayLike<any> ? K | `${K}${D}${FindPath<T[K], Exclude<keyof T[K], keyof any[]>, D>}` : K | `${K}${D}${FindPath<T[K], keyof T[K], D>}` : K : never;
-/** Returns valid paths of object T */
-export type Path<T, D extends string = '.'> = FindPath<T, keyof T, D> | keyof T;
-/** Returns the value of a valid path P `k1.k2.k3` in object T */
-export type PathValue<T, P extends Path<T, D>, D extends string = '.'> = P extends `${infer K}${D}${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K], D> ? PathValue<T[K], Rest, D> : never : never : P extends keyof T ? T[P] : never;
-/** Check if path has a primitive end value and return only the union of end paths */
-export type PathToLiteral<T, K extends Path<T, D>, D extends string = '.', Base extends string = ''> = PathValue<T, K, D> extends string | number ? K extends string | number ? K extends `${infer BasePath}${D}${Base}` ? BasePath : K : never : never;
-/**
- * Reduce all paths to a single map of paths with primitive values removing all extra non stateful paths
- * { path: { sub: 1 } } => { 'path-sub': 1 }
- *
- */
-export type LiteralPaths<T extends Record<string | number, any>, D extends string = '.', Base extends string = ''> = {
-    [K in Path<T, D> as PathToLiteral<T, K, D, Base>]: PathValue<T, PathToLiteral<T, K, D>, D>;
-};
-export declare function flattenScale<T extends Record<string | number, unknown>, P extends string>(object: T, path?: P): LiteralPaths<T, '-', '_'>;
+/**
+ * Returns an exhaustive list of all possible paths of an object T for keys K.
+ * Possibilities are returned as `k1.k2.k3`.
+ */
+export type FindPath<T, K extends keyof T, D extends string = '.'> = K extends string | number ? T[K] extends Record<string | number, any> ? T[K] extends ArrayLike<any> ? K | `${K}${D}${FindPath<T[K], Exclude<keyof T[K], keyof any[]>, D>}` : K | `${K}${D}${FindPath<T[K], keyof T[K], D>}` : K : never;
+/** Returns valid paths of object T */
+export type Path<T, D extends string = '.'> = FindPath<T, keyof T, D> | keyof T;
+/** Returns the value of a valid path P `k1.k2.k3` in object T */
+export type PathValue<T, P extends Path<T, D>, D extends string = '.'> = P extends `${infer K}${D}${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K], D> ? PathValue<T[K], Rest, D> : never : never : P extends keyof T ? T[P] : never;
+/** Check if path has a primitive end value and return only the union of end paths */
+export type PathToLiteral<T, K extends Path<T, D>, D extends string = '.', Base extends string = ''> = PathValue<T, K, D> extends string | number ? K extends string | number ? K extends `${infer BasePath}${D}${Base}` ? BasePath : K : never : never;
+/**
+ * Reduce all paths to a single map of paths with primitive values removing all extra non stateful paths
+ * { path: { sub: 1 } } => { 'path-sub': 1 }
+ *
+ */
+export type LiteralPaths<T extends Record<string | number, any>, D extends string = '.', Base extends string = ''> = {
+    [K in Path<T, D> as PathToLiteral<T, K, D, Base>]: PathValue<T, PathToLiteral<T, K, D>, D>;
+};
+export declare function flattenScale<T extends Record<string | number, unknown>, P extends string>(object: T, path?: P): LiteralPaths<T, '-', '_'>;

package/dist/utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from './createTheme';
-export * from './serializeTokens';
-export * from './flattenScale';
+export * from './createTheme';
+export * from './serializeTokens';
+export * from './flattenScale';

package/dist/utils/serializeTokens.d.ts

@@ -1,19 +1,19 @@
-import { CSSObject } from '@animus-ui/core';
-import { Theme } from '@emotion/react';
-/**
- * Returns an type of any object with { key: 'var(--key) }
- */
-export type KeyAsVariable<T extends Record<string, any>, Prefix extends string> = {
-    [V in keyof T]: `var(--${Prefix}-${SanitizeKey<Extract<V, string>>})`;
-};
-export type SanitizeKey<T extends string> = T extends `${'$'}${infer Y}` ? Y : T;
-type SerializedTokensInput = Record<string, string | number | CSSObject | SerializedTokensInputRecursive>;
-interface SerializedTokensInputRecursive {
-    [i: number]: SerializedTokensInput;
-    [i: string]: SerializedTokensInput;
-}
-export declare const serializeTokens: <T extends SerializedTokensInput, Prefix extends string>(tokens: T, prefix: Prefix, theme: Theme | undefined) => {
-    tokens: KeyAsVariable<T, Prefix>;
-    variables: CSSObject;
-};
-export {};
+import { CSSObject } from '@animus-ui/core';
+import { Theme } from '@emotion/react';
+/**
+ * Returns an type of any object with { key: 'var(--key) }
+ */
+export type KeyAsVariable<T extends Record<string, any>, Prefix extends string> = {
+    [V in keyof T]: `var(--${Prefix}-${SanitizeKey<Extract<V, string>>})`;
+};
+export type SanitizeKey<T extends string> = T extends `${'$'}${infer Y}` ? Y : T;
+type SerializedTokensInput = Record<string, string | number | CSSObject | SerializedTokensInputRecursive>;
+interface SerializedTokensInputRecursive {
+    [i: number]: SerializedTokensInput;
+    [i: string]: SerializedTokensInput;
+}
+export declare const serializeTokens: <T extends SerializedTokensInput, Prefix extends string>(tokens: T, prefix: Prefix, theme: Theme | undefined) => {
+    tokens: KeyAsVariable<T, Prefix>;
+    variables: CSSObject;
+};
+export {};

package/dist/utils/types.d.ts

@@ -1,41 +1,41 @@
-import { AbstractTheme, CSSObject } from '@animus-ui/core';
-/**
- * This is a custom generic that ensures the safety of adding additional values to a theme object without accidentally wiping out
- * required keys like `breakpoints`.  It works by creating a new mapped type and merging the values of the union of Base & Next:
- * 1. If the key exists on both Base and Next return the intersection of both values
- * 2. If the key exists on next use the value on next.
- * 3. If the key exists on base but nothing else use the value on base.
- *
- * The resulting type is then rejoined with keys that cannot be mutated (breakpoints) as the next version of Theme
- */
-export type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
-/** This merges at 2 levels of depth */
-export type Merge<A, B> = {
-    [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? AssignValueIfUnmergable<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
-};
-/** Extract mergable objects */
-export type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
-/** Return B if either A or B is unmergable */
-export type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
-/** Prefer all values from B */
-export type Assign<A, B> = {
-    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
-};
-/** These are keys that are consistent for all theme builds - they are loosely typed as they are not meant to be accessed directly */
-export type PrivateThemeKeys = {
-    _variables: Record<string, CSSObject>;
-    _tokens: Record<string | number, any>;
-};
-/** This allows 3 layers of color aliases to be constructed when adding colorModes
- * @example
- * {
- *   button: {
- *     bg: {
- *       hover: 'someAlias'
- *     }
- *   }
- * }
- *
- * `button-bg-hover`
- * */
-export type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;
+import { AbstractTheme, CSSObject } from '@animus-ui/core';
+/**
+ * This is a custom generic that ensures the safety of adding additional values to a theme object without accidentally wiping out
+ * required keys like `breakpoints`.  It works by creating a new mapped type and merging the values of the union of Base & Next:
+ * 1. If the key exists on both Base and Next return the intersection of both values
+ * 2. If the key exists on next use the value on next.
+ * 3. If the key exists on base but nothing else use the value on base.
+ *
+ * The resulting type is then rejoined with keys that cannot be mutated (breakpoints) as the next version of Theme
+ */
+export type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
+/** This merges at 2 levels of depth */
+export type Merge<A, B> = {
+    [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? AssignValueIfUnmergable<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
+};
+/** Extract mergable objects */
+export type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
+/** Return B if either A or B is unmergable */
+export type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
+/** Prefer all values from B */
+export type Assign<A, B> = {
+    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
+};
+/** These are keys that are consistent for all theme builds - they are loosely typed as they are not meant to be accessed directly */
+export type PrivateThemeKeys = {
+    _variables: Record<string, CSSObject>;
+    _tokens: Record<string | number, any>;
+};
+/** This allows 3 layers of color aliases to be constructed when adding colorModes
+ * @example
+ * {
+ *   button: {
+ *     bg: {
+ *       hover: 'someAlias'
+ *     }
+ *   }
+ * }
+ *
+ * `button-bg-hover`
+ * */
+export type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animus-ui/theming",
-  "version": "0.1.1-beta.25",
+  "version": "0.1.1-beta.26",
   "description": "Theming Utilities",
   "author": "Aaron Robb <airrobb@gmail.com>",
   "homepage": "https://github.com/codecaaron/animus#readme",
@@ -25,13 +25,13 @@
     "url": "https://github.com/codecaaron/animus/issues"
   },
   "dependencies": {
-    "@animus-ui/core": "^0.1.1-beta.24",
-    "@emotion/react": "^11.0.0",
-    "@emotion/styled": "^11.0.0"
+    "@animus-ui/core": "^0.1.1-beta.25",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0"
   },
   "peerDependencies": {
     "lodash": "*",
     "typescript": ">=4.3.5"
   },
-  "gitHead": "42aeb80b573618b883e9740ba803ed54ed29d5e5"
+  "gitHead": "60452a65a6679aaadb95075b8d7f12771164d8fb"
 }