@udixio/theme 1.0.0-beta.10

package/src/config/config.service.ts

@@ -0,0 +1,74 @@
+import { ConfigInterface } from './config.interface';
+
+import { resolve } from 'path';
+import { defaultColors } from '../color';
+import { VariantModel } from '../theme';
+import { AppService } from '../app.service';
+
+export function defineConfig(configObject: ConfigInterface): ConfigInterface {
+  if (!configObject || typeof configObject !== 'object') {
+    throw new Error('The configuration is missing or not an object');
+  }
+  if (!('sourceColor' in configObject)) {
+    throw new Error('Invalid configuration');
+  }
+  return configObject as ConfigInterface;
+}
+
+export class ConfigService {
+  configPath = './theme.config.ts';
+
+  private appService: AppService;
+
+  constructor({ appService }: { appService: AppService }) {
+    this.appService = appService;
+  }
+
+  public async loadConfig(): Promise<void> {
+    const { themeService, colorService, pluginService } = this.appService;
+    const {
+      sourceColor,
+      contrastLevel = 0,
+      isDark = false,
+      variant = VariantModel.tonalSpot,
+      palettes,
+      colors,
+      useDefaultColors = true,
+      plugins,
+    } = await this.getConfig();
+    themeService.create({
+      contrastLevel: contrastLevel,
+      isDark: isDark,
+      sourceColorHex: sourceColor,
+      variant: variant,
+    });
+    if (palettes) {
+      Object.entries(palettes).forEach(([key, value]) =>
+        themeService.addCustomPalette(key, value)
+      );
+    }
+    if (useDefaultColors) {
+      colorService.addColors(defaultColors);
+    }
+    if (colors) {
+      colorService.addColors(colors);
+    }
+    if (plugins) {
+      plugins.forEach((plugin) => {
+        if (Array.isArray(plugin)) {
+          pluginService.addPlugin(plugin[0], plugin[1]);
+        } else {
+          pluginService.addPlugin(plugin, {});
+        }
+      });
+      pluginService.loadPlugins(this.appService);
+    }
+  }
+
+  private async getConfig(): Promise<ConfigInterface> {
+    const path = resolve(this.configPath);
+    const configImport = await import(path);
+    const config: unknown = configImport.default;
+    return config as ConfigInterface;
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from './config.interface';
+export * from './config.module';
+export * from './config.service';

package/src/index.ts

@@ -0,0 +1,11 @@
+export { default as AppContainer } from './app.container';
+export * from './app.container';
+export * from './app.module';
+export * from './app.service';
+export * from './color';
+export * from './config';
+export * from './main';
+export * from './material-color-utilities';
+export * from './plugin';
+export * from './plugins/tailwind';
+export * from './theme';

package/src/main.ts

@@ -0,0 +1,14 @@
+import AppContainer from './app.container';
+import { AppService } from './app.service';
+import { ConfigService } from './config';
+
+export function bootstrap(): AppService {
+  return AppContainer.resolve<AppService>('appService');
+}
+
+export async function bootstrapFromConfig(path?: string): Promise<AppService> {
+  const configService = AppContainer.resolve<ConfigService>('configService');
+  if (path) configService.configPath = path;
+  await configService.loadConfig();
+  return AppContainer.resolve<AppService>('appService');
+}

package/src/material-color-utilities/contrastCurve.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { lerp } from '@material/material-color-utilities';
+
+/**
+ * A class containing a value that changes with the contrast level.
+ *
+ * Usually represents the contrast requirements for a dynamic color on its
+ * background. The four values correspond to values for contrast levels -1.0,
+ * 0.0, 0.5, and 1.0, respectively.
+ */
+export class ContrastCurve {
+  /**
+   * Creates a `ContrastCurve` object.
+   *
+   * @param low Value for contrast level -1.0
+   * @param normal Value for contrast level 0.0
+   * @param medium Value for contrast level 0.5
+   * @param high Value for contrast level 1.0
+   */
+  constructor(
+    readonly low: number,
+    readonly normal: number,
+    readonly medium: number,
+    readonly high: number
+  ) {}
+
+  /**
+   * Returns the value at a given contrast level.
+   *
+   * @param contrastLevel The contrast level. 0.0 is the default (normal); -1.0
+   *     is the lowest; 1.0 is the highest.
+   * @return The value. For contrast ratios, a number between 1.0 and 21.0.
+   */
+  get(contrastLevel: number): number {
+    if (contrastLevel <= -1.0) {
+      return this.low;
+    } else if (contrastLevel < 0.0) {
+      return lerp(this.low, this.normal, (contrastLevel - -1) / 1);
+    } else if (contrastLevel < 0.5) {
+      return lerp(this.normal, this.medium, (contrastLevel - 0) / 0.5);
+    } else if (contrastLevel < 1.0) {
+      return lerp(this.medium, this.high, (contrastLevel - 0.5) / 0.5);
+    } else {
+      return this.high;
+    }
+  }
+}

package/src/material-color-utilities/dynamic_color.ts

@@ -0,0 +1,450 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  clampDouble,
+  Contrast,
+  Hct,
+  TonalPalette,
+} from '@material/material-color-utilities';
+import { ContrastCurve } from './contrastCurve';
+import { ToneDeltaPair } from './toneDeltaPair';
+import { SchemeEntity } from '../theme/entities/scheme.entity';
+
+/**
+ * @param name The name of the dynamic color. Defaults to empty.
+ * @param palette Function that provides a TonalPalette given
+ * SchemeEntity. A TonalPalette is defined by a hue and chroma, so this
+ * replaces the need to specify hue/chroma. By providing a tonal palette, when
+ * contrast adjustments are made, intended chroma can be preserved.
+ * @param tone Function that provides a tone given SchemeEntity.
+ * @param isBackground Whether this dynamic color is a background, with
+ * some other color as the foreground. Defaults to false.
+ * @param background The background of the dynamic color (as a function of a
+ *     `SchemeEntity`), if it exists.
+ * @param secondBackground A second background of the dynamic color (as a
+ *     function of a `SchemeEntity`), if it
+ * exists.
+ * @param contrastCurve A `ContrastCurve` object specifying how its contrast
+ * against its background should behave in various contrast levels options.
+ * @param toneDeltaPair A `ToneDeltaPair` object specifying a tone delta
+ * constraint between two colors. One of them must be the color being
+ * constructed.
+ */
+interface FromPaletteOptions {
+  name?: string;
+  palette: (scheme: SchemeEntity) => TonalPalette;
+  tone: (scheme: SchemeEntity) => number;
+  isBackground?: boolean;
+  background?: (scheme: SchemeEntity) => DynamicColor;
+  secondBackground?: (scheme: SchemeEntity) => DynamicColor;
+  contrastCurve?: ContrastCurve;
+  toneDeltaPair?: (scheme: SchemeEntity) => ToneDeltaPair;
+}
+
+/**
+ * A color that adjusts itself based on UI state provided by SchemeEntity.
+ *
+ * Colors without backgrounds do not change tone when contrast changes. Colors
+ * with backgrounds become closer to their background as contrast lowers, and
+ * further when contrast increases.
+ *
+ * Prefer static constructors. They require either a hexcode, a palette and
+ * tone, or a hue and chroma. Optionally, they can provide a background
+ * DynamicColor.
+ */
+export class DynamicColor {
+  private readonly hctCache = new Map<SchemeEntity, Hct>();
+
+  /**
+   * The base constructor for DynamicColor.
+   *
+   * _Strongly_ prefer using one of the convenience constructors. This class is
+   * arguably too flexible to ensure it can support any scenario. Functional
+   * arguments allow  overriding without risks that come with subclasses.
+   *
+   * For example, the default behavior of adjust tone at max contrast
+   * to be at a 7.0 ratio with its background is principled and
+   * matches accessibility guidance. That does not mean it's the desired
+   * approach for _every_ design system, and every color pairing,
+   * always, in every case.
+   *
+   * @param name The name of the dynamic color. Defaults to empty.
+   * @param palette Function that provides a TonalPalette given
+   * SchemeEntity. A TonalPalette is defined by a hue and chroma, so this
+   * replaces the need to specify hue/chroma. By providing a tonal palette, when
+   * contrast adjustments are made, intended chroma can be preserved.
+   * @param tone Function that provides a tone, given a SchemeEntity.
+   * @param isBackground Whether this dynamic color is a background, with
+   * some other color as the foreground. Defaults to false.
+   * @param background The background of the dynamic color (as a function of a
+   *     `SchemeEntity`), if it exists.
+   * @param secondBackground A second background of the dynamic color (as a
+   *     function of a `SchemeEntity`), if it
+   * exists.
+   * @param contrastCurve A `ContrastCurve` object specifying how its contrast
+   * against its background should behave in various contrast levels options.
+   * @param toneDeltaPair A `ToneDeltaPair` object specifying a tone delta
+   * constraint between two colors. One of them must be the color being
+   * constructed.
+   */
+  constructor(
+    readonly name: string,
+    readonly palette: (scheme: SchemeEntity) => TonalPalette,
+    readonly tone: (scheme: SchemeEntity) => number,
+    readonly isBackground: boolean,
+    readonly background?: (scheme: SchemeEntity) => DynamicColor,
+    readonly secondBackground?: (scheme: SchemeEntity) => DynamicColor,
+    readonly contrastCurve?: ContrastCurve,
+    readonly toneDeltaPair?: (scheme: SchemeEntity) => ToneDeltaPair
+  ) {
+    if (!background && secondBackground) {
+      throw new Error(
+        `Color ${name} has secondBackground` +
+          `defined, but background is not defined.`
+      );
+    }
+    if (!background && contrastCurve) {
+      throw new Error(
+        `Color ${name} has contrastCurve` +
+          `defined, but background is not defined.`
+      );
+    }
+    if (background && !contrastCurve) {
+      throw new Error(
+        `Color ${name} has background` +
+          `defined, but contrastCurve is not defined.`
+      );
+    }
+  }
+
+  /**
+   * Create a DynamicColor defined by a TonalPalette and HCT tone.
+   *
+   * @param args Functions with SchemeEntity as input. Must provide a palette
+   * and tone. May provide a background DynamicColor and ToneDeltaConstraint.
+   */
+  static fromPalette(args: FromPaletteOptions): DynamicColor {
+    return new DynamicColor(
+      args.name ?? '',
+      args.palette,
+      args.tone,
+      args.isBackground ?? false,
+      args.background,
+      args.secondBackground,
+      args.contrastCurve,
+      args.toneDeltaPair
+    );
+  }
+
+  /**
+   * Given a background tone, find a foreground tone, while ensuring they reach
+   * a contrast ratio that is as close to [ratio] as possible.
+   *
+   * @param bgTone Tone in HCT. Range is 0 to 100, undefined behavior when it
+   *     falls outside that range.
+   * @param ratio The contrast ratio desired between bgTone and the return
+   *     value.
+   */
+  static foregroundTone(bgTone: number, ratio: number): number {
+    const lighterTone = Contrast.lighterUnsafe(bgTone, ratio);
+    const darkerTone = Contrast.darkerUnsafe(bgTone, ratio);
+    const lighterRatio = Contrast.ratioOfTones(lighterTone, bgTone);
+    const darkerRatio = Contrast.ratioOfTones(darkerTone, bgTone);
+    const preferLighter = DynamicColor.tonePrefersLightForeground(bgTone);
+
+    if (preferLighter) {
+      // This handles an edge case where the initial contrast ratio is high
+      // (ex. 13.0), and the ratio passed to the function is that high
+      // ratio, and both the lighter and darker ratio fails to pass that
+      // ratio.
+      //
+      // This was observed with Tonal Spot's On Primary Container turning
+      // black momentarily between high and max contrast in light mode. PC's
+      // standard tone was T90, OPC's was T10, it was light mode, and the
+      // contrast value was 0.6568521221032331.
+      const negligibleDifference =
+        Math.abs(lighterRatio - darkerRatio) < 0.1 &&
+        lighterRatio < ratio &&
+        darkerRatio < ratio;
+      return lighterRatio >= ratio ||
+        lighterRatio >= darkerRatio ||
+        negligibleDifference
+        ? lighterTone
+        : darkerTone;
+    } else {
+      return darkerRatio >= ratio || darkerRatio >= lighterRatio
+        ? darkerTone
+        : lighterTone;
+    }
+  }
+
+  /**
+   * Returns whether [tone] prefers a light foreground.
+   *
+   * People prefer white foregrounds on ~T60-70. Observed over time, and also
+   * by Andrew Somers during research for APCA.
+   *
+   * T60 used as to create the smallest discontinuity possible when skipping
+   * down to T49 in order to ensure light foregrounds.
+   * Since `tertiaryContainer` in dark monochrome scheme requires a tone of
+   * 60, it should not be adjusted. Therefore, 60 is excluded here.
+   */
+  static tonePrefersLightForeground(tone: number): boolean {
+    return Math.round(tone) < 60.0;
+  }
+
+  /**
+   * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
+   * color.
+   */
+  static toneAllowsLightForeground(tone: number): boolean {
+    return Math.round(tone) <= 49.0;
+  }
+
+  /**
+   * Adjust a tone such that white has 4.5 contrast, if the tone is
+   * reasonably close to supporting it.
+   */
+  static enableLightForeground(tone: number): number {
+    if (
+      DynamicColor.tonePrefersLightForeground(tone) &&
+      !DynamicColor.toneAllowsLightForeground(tone)
+    ) {
+      return 49.0;
+    }
+    return tone;
+  }
+
+  /**
+   * Return a ARGB integer (i.e. a hex code).
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   * whether or not it is dark mode or light mode, and what the desired
+   * contrast level is.
+   */
+  getArgb(scheme: SchemeEntity): number {
+    return this.getHct(scheme).toInt();
+  }
+
+  /**
+   * Return a color, expressed in the HCT color space, that this
+   * DynamicColor is under the conditions in scheme.
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   * whether or not it is dark mode or light mode, and what the desired
+   * contrast level is.
+   */
+  getHct(scheme: SchemeEntity): Hct {
+    const cachedAnswer = this.hctCache.get(scheme);
+    if (cachedAnswer != null) {
+      return cachedAnswer;
+    }
+    const tone = this.getTone(scheme);
+    const answer = this.palette(scheme).getHct(tone);
+    if (this.hctCache.size > 4) {
+      this.hctCache.clear();
+    }
+    this.hctCache.set(scheme, answer);
+    return answer;
+  }
+
+  /**
+   * Return a tone, T in the HCT color space, that this DynamicColor is under
+   * the conditions in scheme.
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   * whether or not it is dark mode or light mode, and what the desired
+   * contrast level is.
+   */
+  getTone(scheme: SchemeEntity): number {
+    const decreasingContrast = scheme.contrastLevel < 0;
+
+    // Case 1: dual foreground, pair of colors with delta constraint.
+    if (this.toneDeltaPair) {
+      const toneDeltaPair = this.toneDeltaPair(scheme);
+      const roleA = toneDeltaPair.roleA;
+      const roleB = toneDeltaPair.roleB;
+      const delta = toneDeltaPair.delta;
+      const polarity = toneDeltaPair.polarity;
+      const stayTogether = toneDeltaPair.stayTogether;
+
+      const bg = this.background!(scheme);
+      const bgTone = bg.getTone(scheme);
+
+      const aIsNearer =
+        polarity === 'nearer' ||
+        (polarity === 'lighter' && !scheme.isDark) ||
+        (polarity === 'darker' && scheme.isDark);
+      const nearer = aIsNearer ? roleA : roleB;
+      const farther = aIsNearer ? roleB : roleA;
+      const amNearer = this.name === nearer.name;
+      const expansionDir = scheme.isDark ? 1 : -1;
+
+      // 1st round: solve to min, each
+      const nContrast = nearer.contrastCurve!.get(scheme.contrastLevel);
+      const fContrast = farther.contrastCurve!.get(scheme.contrastLevel);
+
+      // If a color is good enough, it is not adjusted.
+      // Initial and adjusted tones for `nearer`
+      const nInitialTone = nearer.tone(scheme);
+      let nTone =
+        Contrast.ratioOfTones(bgTone, nInitialTone) >= nContrast
+          ? nInitialTone
+          : DynamicColor.foregroundTone(bgTone, nContrast);
+      // Initial and adjusted tones for `farther`
+      const fInitialTone = farther.tone(scheme);
+      let fTone =
+        Contrast.ratioOfTones(bgTone, fInitialTone) >= fContrast
+          ? fInitialTone
+          : DynamicColor.foregroundTone(bgTone, fContrast);
+
+      if (decreasingContrast) {
+        // If decreasing contrast, adjust color to the "bare minimum"
+        // that satisfies contrast.
+        nTone = DynamicColor.foregroundTone(bgTone, nContrast);
+        fTone = DynamicColor.foregroundTone(bgTone, fContrast);
+      }
+
+      if ((fTone - nTone) * expansionDir >= delta) {
+        // Good! Tones satisfy the constraint; no change needed.
+      } else {
+        // 2nd round: expand farther to match delta.
+        fTone = clampDouble(0, 100, nTone + delta * expansionDir);
+        if ((fTone - nTone) * expansionDir >= delta) {
+          // Good! Tones now satisfy the constraint; no change needed.
+        } else {
+          // 3rd round: contract nearer to match delta.
+          nTone = clampDouble(0, 100, fTone - delta * expansionDir);
+        }
+      }
+
+      // Avoids the 50-59 awkward zone.
+      if (50 <= nTone && nTone < 60) {
+        // If `nearer` is in the awkward zone, move it away, together with
+        // `farther`.
+        if (expansionDir > 0) {
+          nTone = 60;
+          fTone = Math.max(fTone, nTone + delta * expansionDir);
+        } else {
+          nTone = 49;
+          fTone = Math.min(fTone, nTone + delta * expansionDir);
+        }
+      } else if (50 <= fTone && fTone < 60) {
+        if (stayTogether) {
+          // Fixes both, to avoid two colors on opposite sides of the "awkward
+          // zone".
+          if (expansionDir > 0) {
+            nTone = 60;
+            fTone = Math.max(fTone, nTone + delta * expansionDir);
+          } else {
+            nTone = 49;
+            fTone = Math.min(fTone, nTone + delta * expansionDir);
+          }
+        } else {
+          // Not required to stay together; fixes just one.
+          if (expansionDir > 0) {
+            fTone = 60;
+          } else {
+            fTone = 49;
+          }
+        }
+      }
+
+      // Returns `nTone` if this color is `nearer`, otherwise `fTone`.
+      return amNearer ? nTone : fTone;
+    } else {
+      // Case 2: No contrast pair; just solve for itself.
+      let answer = this.tone(scheme);
+
+      if (this.background == null) {
+        return answer; // No adjustment for colors with no background.
+      }
+
+      const bgTone = this.background(scheme).getTone(scheme);
+
+      const desiredRatio = this.contrastCurve!.get(scheme.contrastLevel);
+
+      if (Contrast.ratioOfTones(bgTone, answer) >= desiredRatio) {
+        // Don't "improve" what's good enough.
+      } else {
+        // Rough improvement.
+        answer = DynamicColor.foregroundTone(bgTone, desiredRatio);
+      }
+
+      if (decreasingContrast) {
+        answer = DynamicColor.foregroundTone(bgTone, desiredRatio);
+      }
+
+      if (this.isBackground && 50 <= answer && answer < 60) {
+        // Must adjust
+        if (Contrast.ratioOfTones(49, bgTone) >= desiredRatio) {
+          answer = 49;
+        } else {
+          answer = 60;
+        }
+      }
+
+      if (this.secondBackground) {
+        // Case 3: Adjust for dual backgrounds.
+
+        const [bg1, bg2] = [this.background, this.secondBackground];
+        const [bgTone1, bgTone2] = [
+          bg1(scheme).getTone(scheme),
+          bg2(scheme).getTone(scheme),
+        ];
+        const [upper, lower] = [
+          Math.max(bgTone1, bgTone2),
+          Math.min(bgTone1, bgTone2),
+        ];
+
+        if (
+          Contrast.ratioOfTones(upper, answer) >= desiredRatio &&
+          Contrast.ratioOfTones(lower, answer) >= desiredRatio
+        ) {
+          return answer;
+        }
+
+        // The darkest light tone that satisfies the desired ratio,
+        // or -1 if such ratio cannot be reached.
+        const lightOption = Contrast.lighter(upper, desiredRatio);
+
+        // The lightest dark tone that satisfies the desired ratio,
+        // or -1 if such ratio cannot be reached.
+        const darkOption = Contrast.darker(lower, desiredRatio);
+
+        // Tones suitable for the foreground.
+        const availables = [];
+        if (lightOption !== -1) availables.push(lightOption);
+        if (darkOption !== -1) availables.push(darkOption);
+
+        const prefersLight =
+          DynamicColor.tonePrefersLightForeground(bgTone1) ||
+          DynamicColor.tonePrefersLightForeground(bgTone2);
+        if (prefersLight) {
+          return lightOption < 0 ? 100 : lightOption;
+        }
+        if (availables.length === 1) {
+          return availables[0];
+        }
+        return darkOption < 0 ? 0 : darkOption;
+      }
+
+      return answer;
+    }
+  }
+}

package/src/material-color-utilities/index.ts

@@ -0,0 +1,3 @@
+export * from './contrastCurve';
+export * from './dynamic_color';
+export * from './toneDeltaPair';

package/src/material-color-utilities/toneDeltaPair.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { DynamicColor } from './dynamic_color';
+
+/**
+ * Describes the different in tone between colors.
+ */
+export type TonePolarity = 'darker' | 'lighter' | 'nearer' | 'farther';
+
+/**
+ * Documents a constraint between two DynamicColors, in which their tones must
+ * have a certain distance from each other.
+ *
+ * Prefer a DynamicColor with a background, this is for special cases when
+ * designers want tonal distance, literally contrast, between two colors that
+ * don't have a background / foreground relationship or a contrast guarantee.
+ */
+export class ToneDeltaPair {
+  /**
+   * Documents a constraint in tone distance between two DynamicColors.
+   *
+   * The polarity is an adjective that describes "A", compared to "B".
+   *
+   * For instance, ToneDeltaPair(A, B, 15, 'darker', stayTogether) states that
+   * A's tone should be at least 15 darker than B's.
+   *
+   * 'nearer' and 'farther' describes closeness to the surface roles. For
+   * instance, ToneDeltaPair(A, B, 10, 'nearer', stayTogether) states that A
+   * should be 10 lighter than B in light mode, and 10 darker than B in dark
+   * mode.
+   *
+   * @param roleA The first role in a pair.
+   * @param roleB The second role in a pair.
+   * @param delta Required difference between tones. Absolute value, negative
+   * values have undefined behavior.
+   * @param polarity The relative relation between tones of roleA and roleB,
+   * as described above.
+   * @param stayTogether Whether these two roles should stay on the same side of
+   * the "awkward zone" (T50-59). This is necessary for certain cases where
+   * one role has two backgrounds.
+   */
+  constructor(
+    readonly roleA: DynamicColor,
+    readonly roleB: DynamicColor,
+    readonly delta: number,
+    readonly polarity: TonePolarity,
+    readonly stayTogether: boolean
+  ) {}
+}

package/src/plugin/index.ts

@@ -0,0 +1,3 @@
+export * from './plugin.abstract';
+export * from './plugin.module';
+export * from './plugin.service';