Function createTheme

packages/@react-spectrum/s2/style/style-macro.ts:286–777

(
  theme: T
)

let isCompilingDependencies: boolean | null | string = false;

export function createTheme<T extends Theme>(
  theme: T
): StyleFunction<ThemeProperties<T>, 'default' | Extract<keyof T['conditions'], string>> {
  let properties = new Map<string, Property<any>>(
    Object.entries(theme.properties).map(([k, v]) => {
      if (!Array.isArray(v) && v.cssProperties) {
        return [k, v as Property<any>];
      }

      return [k, new MappedProperty(k, v as any)];
    })
  );

  let dependencies = new Set<string>();
  let hasConditions = false;
  return function style(this: MacroContext | void, style, allowedOverrides?: readonly string[]) {
    // Check if `this` is undefined, which means style was not called as a macro but as a normal function.
    // We also check if this is globalThis, which happens in non-strict mode bundles.
    // Also allow style to be called as a normal function in tests.
    // @ts-ignore

    if ((this == null || this === globalThis) && process.env.NODE_ENV !== 'test') {
      throw new Error('The style macro must be imported with {type: "macro"}.');
    }

    // Generate rules for each property.
    let rules = new Map<string, Rule>();
    let values = new Map();
    dependencies.clear();
    let usedPriorities = 0;
    let setRules = (key: string, value: [number, Rule[]]) => {
      usedPriorities = Math.max(usedPriorities, value[0]);
      rules.set(key, new GroupRule(value[1]));
    };

    hasConditions = false;
    for (let key in style) {
      let value = style[key]!;
      let themeProperty = key;
      values.set(key, value);

      // Get the type of custom properties in the theme.
      if (key.startsWith('--')) {
        themeProperty = value.type;
        value = value.value;
      }

      // Expand shorthands to longhands so that merging works as expected.
      if (theme.shorthands[key]) {
        let shorthand = theme.shorthands[key];
        if (typeof shorthand === 'function') {
          let expanded = mapConditionalShorthand(value, shorthand);
          for (let k in expanded) {
            let v = expanded[k];
            values.set(k, v);
            setRules(k, compileValue(k, k, v));
          }
        } else {