TypeScript merge-styles.Stylesheet类代码示例

export function print(
  val: string,
  serialize: () => string,
  indent: (val: string) => string
): string {
  const classNames = [];
  const rules = [];
  const parts = val.split(' ');

  for (const part of parts) {
    const ruleSet = Stylesheet.getInstance().insertedRulesFromClassName(part);

    if (ruleSet) {
      rules.push(_serializeRules(ruleSet, indent));
    } else {
      classNames.push(part);
    }
  }

  return (
    [
      ``,
      `${classNames.map((cn: string) => indent(cn)).join('\n')}`,
      `${rules.join('\n')}`
    ].join('\n')
  );
}

/**
 * Given a ruleSet (an array of doubles (selector and insertedRules string)), and an indent,
 * produce a serialized version of the rules.
 */
function _serializeRules(rules: string[], indent: (val: string) => string): string {
  const ruleStrings: string[] = [];
  const stylesheet = Stylesheet.getInstance();

  for (let i = 0; i < rules.length; i += 2) {
    const selector = rules[i];
    const insertedRules = rules[i + 1];

    if (insertedRules) {
      // Keyframes should not be parsed like other selector/rule mappings.
      if (selector !== 'keyframes') {
        ruleStrings.push(indent((i === 0 ? '' : selector + ' ') + `{`));
        insertedRules
          .split(';')
          .sort()
          .forEach((rule: string) => {
            if (rule) {
              const [name, value] = rule.split(':');
              let delimiter: string | RegExp = ' ';

              if (name === 'animation-name') {
                delimiter = /[ ,]+/;
              }

              let result: string[] = [];

              if (value) {
                const valueParts = value.split(delimiter);

                for (const part of valueParts) {
                  const ruleSet = stylesheet.insertedRulesFromClassName(part);

                  if (ruleSet) {
                    result = result.concat(ruleSet);
                  } else {
                    result.push(part);
                  }
                }
              }

              ruleStrings.push(indent(`  ${name}: ${result.join(' ')};`));
            }
          });

        ruleStrings.push(indent('}'));
      }
    }
  }

  return ruleStrings.join('\n');
}

  <T>(classNames: GlobalClassNames<T>, disableGlobalClassNames?: boolean): Partial<GlobalClassNames<T>> => {
    const styleSheet = Stylesheet.getInstance();

    if (disableGlobalClassNames) {
      // disable global classnames
      return Object.keys(classNames).reduce((acc: {}, className: string) => {
        acc[className] = styleSheet.getClassName(classNames[className]);
        return acc;
      }, {});
    }

    // use global classnames
    return classNames;
  }

export function print(val: string, serialize: () => string, indent: (val: string) => string): string {
  const classNames = [];
  const rules = [];
  const parts = val.split(' ');

  // Iterate through all class names in the value, and for each, determine if merge-styles
  // has a ruleset registered for the class. If so, serialize it to an expanded string. If not
  // add it to the static classNames array, as it's likely a global class name.
  for (const part of parts) {
    const ruleSet = Stylesheet.getInstance().insertedRulesFromClassName(part);

    if (ruleSet) {
      rules.push(_serializeRules(ruleSet, indent));
    } else {
      classNames.push(part);
    }
  }

  return [``, `${classNames.map((cn: string) => indent(cn)).join('\n')}`, `${rules.join('\n')}`].join('\n');
}

function _serializeRules(rules: string[], indent: (val: string) => string): string {
  const ruleStrings: string[] = [];
  const stylesheet = Stylesheet.getInstance();

  for (let i = 0; i < rules.length; i += 2) {
    const selector = rules[i];
    const insertedRules = rules[i + 1];

    if (insertedRules) {
      ruleStrings.push(indent((i === 0 ? '' : selector + ' ') + `{`));

      insertedRules.split(';').sort().forEach((rule: string) => {
        if (rule) {
          const [name, value] = rule.split(':');
          const valueParts = value.split(' ');
          let result: string[] = [];

          for (const part of valueParts) {
            const ruleSet = stylesheet.insertedRulesFromClassName(part);

            if (ruleSet) {
              result = result.concat(ruleSet);
            } else {
              result.push(part);
            }
          }

          ruleStrings.push(indent(`  ${name}: ${result.join(' ')};`));
        }
      });

      ruleStrings.push(indent('}'));
    }
  }

  return ruleStrings.join('\n');
}

  __remapped: { [key: string]: string };
  [key: string]: IIconRecord | {};
}

const ICON_SETTING_NAME = 'icons';

const _iconSettings = GlobalSettings.getValue<IIconRecords>(ICON_SETTING_NAME, {
  __options: {
    disableWarnings: false,
    warnOnMissingIcons: true
  },
  __remapped: {}
});

// Reset icon registration on stylesheet resets.
const stylesheet = Stylesheet.getInstance();

if (stylesheet && stylesheet.onReset) {
  stylesheet.onReset(() => {
    for (const name in _iconSettings) {
      if (_iconSettings.hasOwnProperty(name) && !!(_iconSettings[name] as IIconRecord).subset) {
        (_iconSettings[name] as IIconRecord).subset.className = undefined;
      }
    }
  });
}

/**
 * Registers a given subset of icons.
 *
 * @param iconSubset - the icon subset definition.

 return parts.some((part: string): boolean => !!Stylesheet.getInstance().insertedRulesFromClassName(part));

import { Stylesheet } from '@uifabric/merge-styles';

const stylesheet = Stylesheet.getInstance();

if (stylesheet && stylesheet.onReset) {
  Stylesheet.getInstance().onReset(resetMemoizations);
}

// tslint:disable:no-any
declare class WeakMap {
  public get(key: any): any;
  public set(key: any, value: any): void;
  public has(key: any): boolean;
}

let _resetCounter = 0;
const _emptyObject = { empty: true };
const _dictionary: any = {};
let _weakMap = typeof WeakMap === 'undefined' ? null : WeakMap;

interface IMemoizeNode {
  map: WeakMap | null;
  value?: any;
}

/**
 *  Test utility for providing a custom weakmap.
 *
 * @internal
 * */
export function setMemoizeWeakMap(weakMap: any): void {