@wordpress/block-editor/build/components/global-styles/typography-panel.js

Generic block editor.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = TypographyPanel;
exports.useHasTypographyPanel = useHasTypographyPanel;

var _element = require("@wordpress/element");

var _components = require("@wordpress/components");

var _i18n = require("@wordpress/i18n");

var _fontFamily = _interopRequireDefault(require("../font-family"));

var _fontAppearanceControl = _interopRequireDefault(require("../font-appearance-control"));

var _lineHeightControl = _interopRequireDefault(require("../line-height-control"));

var _letterSpacingControl = _interopRequireDefault(require("../letter-spacing-control"));

var _textTransformControl = _interopRequireDefault(require("../text-transform-control"));

var _textDecorationControl = _interopRequireDefault(require("../text-decoration-control"));

var _utils = require("./utils");

var _object = require("../../utils/object");

/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */
const MIN_TEXT_COLUMNS = 1;
const MAX_TEXT_COLUMNS = 6;

function useHasTypographyPanel(settings) {
  const hasFontFamily = useHasFontFamilyControl(settings);
  const hasLineHeight = useHasLineHeightControl(settings);
  const hasFontAppearance = useHasAppearanceControl(settings);
  const hasLetterSpacing = useHasLetterSpacingControl(settings);
  const hasTextTransform = useHasTextTransformControl(settings);
  const hasTextDecoration = useHasTextDecorationControl(settings);
  const hasTextColumns = useHasTextColumnsControl(settings);
  const hasFontSize = useHasFontSizeControl(settings);
  return hasFontFamily || hasLineHeight || hasFontAppearance || hasLetterSpacing || hasTextTransform || hasFontSize || hasTextDecoration || hasTextColumns;
}

function useHasFontSizeControl(settings) {
  var _settings$typography$, _ref, _fontSizesPerOrigin$c;

  const disableCustomFontSizes = !settings?.typography?.customFontSize;
  const fontSizesPerOrigin = (_settings$typography$ = settings?.typography?.fontSizes) !== null && _settings$typography$ !== void 0 ? _settings$typography$ : {};
  const fontSizes = (_ref = (_fontSizesPerOrigin$c = fontSizesPerOrigin?.custom) !== null && _fontSizesPerOrigin$c !== void 0 ? _fontSizesPerOrigin$c : fontSizesPerOrigin?.theme) !== null && _ref !== void 0 ? _ref : fontSizesPerOrigin.default;
  return !!fontSizes?.length || !disableCustomFontSizes;
}

function useHasFontFamilyControl(settings) {
  var _ref2, _fontFamiliesPerOrigi;

  const fontFamiliesPerOrigin = settings?.typography?.fontFamilies;
  const fontFamilies = (_ref2 = (_fontFamiliesPerOrigi = fontFamiliesPerOrigin?.custom) !== null && _fontFamiliesPerOrigi !== void 0 ? _fontFamiliesPerOrigi : fontFamiliesPerOrigin?.theme) !== null && _ref2 !== void 0 ? _ref2 : fontFamiliesPerOrigin?.default;
  return !!fontFamilies?.length;
}

function useHasLineHeightControl(settings) {
  return settings?.typography?.lineHeight;
}

function useHasAppearanceControl(settings) {
  const hasFontStyles = settings?.typography?.fontStyle;
  const hasFontWeights = settings?.typography?.fontWeight;
  return hasFontStyles || hasFontWeights;
}

function useAppearanceControlLabel(settings) {
  const hasFontStyles = settings?.typography?.fontStyle;
  const hasFontWeights = settings?.typography?.fontWeight;

  if (!hasFontStyles) {
    return (0, _i18n.__)('Font weight');
  }

  if (!hasFontWeights) {
    return (0, _i18n.__)('Font style');
  }

  return (0, _i18n.__)('Appearance');
}

function useHasLetterSpacingControl(settings) {
  return settings?.typography?.letterSpacing;
}

function useHasTextTransformControl(settings) {
  return settings?.typography?.textTransform;
}

function useHasTextDecorationControl(settings) {
  return settings?.typography?.textDecoration;
}

function useHasTextColumnsControl(settings) {
  return settings?.typography?.textColumns;
}

function TypographyToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children
}) {
  const resetAll = () => {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };

  return (0, _element.createElement)(_components.__experimentalToolsPanel, {
    label: (0, _i18n.__)('Typography'),
    resetAll: resetAll,
    panelId: panelId
  }, children);
}

const DEFAULT_CONTROLS = {
  fontFamily: true,
  fontSize: true,
  fontAppearance: true,
  lineHeight: true,
  letterSpacing: true,
  textTransform: true,
  textDecoration: true,
  textColumns: true
};

function TypographyPanel({
  as: Wrapper = TypographyToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  defaultControls = DEFAULT_CONTROLS
}) {
  var _ref3, _fontFamiliesPerOrigi2, _settings$typography$2, _ref4, _fontSizesPerOrigin$c2;

  const decodeValue = rawValue => (0, _utils.getValueFromVariable)({
    settings
  }, '', rawValue); // Font Family


  const hasFontFamilyEnabled = useHasFontFamilyControl(settings);
  const fontFamiliesPerOrigin = settings?.typography?.fontFamilies;
  const fontFamilies = (_ref3 = (_fontFamiliesPerOrigi2 = fontFamiliesPerOrigin?.custom) !== null && _fontFamiliesPerOrigi2 !== void 0 ? _fontFamiliesPerOrigi2 : fontFamiliesPerOrigin?.theme) !== null && _ref3 !== void 0 ? _ref3 : fontFamiliesPerOrigin?.default;
  const fontFamily = decodeValue(inheritedValue?.typography?.fontFamily);

  const setFontFamily = newValue => {
    const slug = fontFamilies?.find(({
      fontFamily: f
    }) => f === newValue)?.slug;
    onChange((0, _object.setImmutably)(value, ['typography', 'fontFamily'], slug ? `var:preset|font-family|${slug}` : newValue || undefined));
  };

  const hasFontFamily = () => !!value?.typography?.fontFamily;

  const resetFontFamily = () => setFontFamily(undefined); // Font Size


  const hasFontSizeEnabled = useHasFontSizeControl(settings);
  const disableCustomFontSizes = !settings?.typography?.customFontSize;
  const fontSizesPerOrigin = (_settings$typography$2 = settings?.typography?.fontSizes) !== null && _settings$typography$2 !== void 0 ? _settings$typography$2 : {};
  const fontSizes = (_ref4 = (_fontSizesPerOrigin$c2 = fontSizesPerOrigin?.custom) !== null && _fontSizesPerOrigin$c2 !== void 0 ? _fontSizesPerOrigin$c2 : fontSizesPerOrigin?.theme) !== null && _ref4 !== void 0 ? _ref4 : fontSizesPerOrigin.default;
  const fontSize = decodeValue(inheritedValue?.typography?.fontSize);

  const setFontSize = (newValue, metadata) => {
    const actualValue = !!metadata?.slug ? `var:preset|font-size|${metadata?.slug}` : newValue;
    onChange((0, _object.setImmutably)(value, ['typography', 'fontSize'], actualValue || undefined));
  };

  const hasFontSize = () => !!value?.typography?.fontSize;

  const resetFontSize = () => setFontSize(undefined); // Appearance


  const hasAppearanceControl = useHasAppearanceControl(settings);
  const appearanceControlLabel = useAppearanceControlLabel(settings);
  const hasFontStyles = settings?.typography?.fontStyle;
  const hasFontWeights = settings?.typography?.fontWeight;
  const fontStyle = decodeValue(inheritedValue?.typography?.fontStyle);
  const fontWeight = decodeValue(inheritedValue?.typography?.fontWeight);

  const setFontAppearance = ({
    fontStyle: newFontStyle,
    fontWeight: newFontWeight
  }) => {
    onChange({ ...value,
      typography: { ...value?.typography,
        fontStyle: newFontStyle || undefined,
        fontWeight: newFontWeight || undefined
      }
    });
  };

  const hasFontAppearance = () => !!value?.typography?.fontStyle || !!value?.typography?.fontWeight;

  const resetFontAppearance = () => {
    setFontAppearance({});
  }; // Line Height


  const hasLineHeightEnabled = useHasLineHeightControl(settings);
  const lineHeight = decodeValue(inheritedValue?.typography?.lineHeight);

  const setLineHeight = newValue => {
    onChange((0, _object.setImmutably)(value, ['typography', 'lineHeight'], newValue || undefined));
  };

  const hasLineHeight = () => value?.typography?.lineHeight !== undefined;

  const resetLineHeight = () => setLineHeight(undefined); // Letter Spacing


  const hasLetterSpacingControl = useHasLetterSpacingControl(settings);
  const letterSpacing = decodeValue(inheritedValue?.typography?.letterSpacing);

  const setLetterSpacing = newValue => {
    onChange((0, _object.setImmutably)(value, ['typography', 'letterSpacing'], newValue || undefined));
  };

  const hasLetterSpacing = () => !!value?.typography?.letterSpacing;

  const resetLetterSpacing = () => setLetterSpacing(undefined); // Text Columns


  const hasTextColumnsControl = useHasTextColumnsControl(settings);
  const textColumns = decodeValue(inheritedValue?.typography?.textColumns);

  const setTextColumns = newValue => {
    onChange((0, _object.setImmutably)(value, ['typography', 'textColumns'], newValue || undefined));
  };

  const hasTextColumns = () => !!value?.typography?.textColumns;

  const resetTextColumns = () => setTextColumns(undefined); // Text Transform


  const hasTextTransformControl = useHasTextTransformControl(settings);
  const textTransform = decodeValue(inheritedValue?.typography?.textTransform);

  const setTextTransform = newValue => {
    onChange((0, _object.setImmutably)(value, ['typography', 'textTransform'], newValue || undefined));
  };

  const hasTextTransform = () => !!value?.typography?.textTransform;

  const resetTextTransform = () => setTextTransform(undefined); // Text Decoration


  const hasTextDecorationControl = useHasTextDecorationControl(settings);
  const textDecoration = decodeValue(inheritedValue?.typography?.textDecoration);

  const setTextDecoration = newValue => {
    onChange((0, _object.setImmutably)(value, ['typography', 'textDecoration'], newValue || undefined));
  };

  const hasTextDecoration = () => !!value?.typography?.textDecoration;

  const resetTextDecoration = () => setTextDecoration(undefined);

  const resetAllFilter = (0, _element.useCallback)(previousValue => {
    return { ...previousValue,
      typography: {}
    };
  }, []);
  return (0, _element.createElement)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId
  }, hasFontFamilyEnabled && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    label: (0, _i18n.__)('Font family'),
    hasValue: hasFontFamily,
    onDeselect: resetFontFamily,
    isShownByDefault: defaultControls.fontFamily,
    panelId: panelId
  }, (0, _element.createElement)(_fontFamily.default, {
    fontFamilies: fontFamilies,
    value: fontFamily,
    onChange: setFontFamily,
    size: "__unstable-large",
    __nextHasNoMarginBottom: true
  })), hasFontSizeEnabled && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    label: (0, _i18n.__)('Font size'),
    hasValue: hasFontSize,
    onDeselect: resetFontSize,
    isShownByDefault: defaultControls.fontSize,
    panelId: panelId
  }, (0, _element.createElement)(_components.FontSizePicker, {
    value: fontSize,
    onChange: setFontSize,
    fontSizes: fontSizes,
    disableCustomFontSizes: disableCustomFontSizes,
    withReset: false,
    withSlider: true,
    size: "__unstable-large",
    __nextHasNoMarginBottom: true
  })), hasAppearanceControl && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    className: "single-column",
    label: appearanceControlLabel,
    hasValue: hasFontAppearance,
    onDeselect: resetFontAppearance,
    isShownByDefault: defaultControls.fontAppearance,
    panelId: panelId
  }, (0, _element.createElement)(_fontAppearanceControl.default, {
    value: {
      fontStyle,
      fontWeight
    },
    onChange: setFontAppearance,
    hasFontStyles: hasFontStyles,
    hasFontWeights: hasFontWeights,
    size: "__unstable-large",
    __nextHasNoMarginBottom: true
  })), hasLineHeightEnabled && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    className: "single-column",
    label: (0, _i18n.__)('Line height'),
    hasValue: hasLineHeight,
    onDeselect: resetLineHeight,
    isShownByDefault: defaultControls.lineHeight,
    panelId: panelId
  }, (0, _element.createElement)(_lineHeightControl.default, {
    __nextHasNoMarginBottom: true,
    __unstableInputWidth: "auto",
    value: lineHeight,
    onChange: setLineHeight,
    size: "__unstable-large"
  })), hasLetterSpacingControl && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    className: "single-column",
    label: (0, _i18n.__)('Letter spacing'),
    hasValue: hasLetterSpacing,
    onDeselect: resetLetterSpacing,
    isShownByDefault: defaultControls.letterSpacing,
    panelId: panelId
  }, (0, _element.createElement)(_letterSpacingControl.default, {
    value: letterSpacing,
    onChange: setLetterSpacing,
    size: "__unstable-large",
    __unstableInputWidth: "auto"
  })), hasTextColumnsControl && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    className: "single-column",
    label: (0, _i18n.__)('Text columns'),
    hasValue: hasTextColumns,
    onDeselect: resetTextColumns,
    isShownByDefault: defaultControls.textColumns,
    panelId: panelId
  }, (0, _element.createElement)(_components.__experimentalNumberControl, {
    label: (0, _i18n.__)('Text columns'),
    max: MAX_TEXT_COLUMNS,
    min: MIN_TEXT_COLUMNS,
    onChange: setTextColumns,
    size: "__unstable-large",
    spinControls: "custom",
    value: textColumns,
    initialPosition: 1
  })), hasTextDecorationControl && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    className: "single-column",
    label: (0, _i18n.__)('Text decoration'),
    hasValue: hasTextDecoration,
    onDeselect: resetTextDecoration,
    isShownByDefault: defaultControls.textDecoration,
    panelId: panelId
  }, (0, _element.createElement)(_textDecorationControl.default, {
    value: textDecoration,
    onChange: setTextDecoration,
    size: "__unstable-large",
    __unstableInputWidth: "auto"
  })), hasTextTransformControl && (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
    label: (0, _i18n.__)('Letter case'),
    hasValue: hasTextTransform,
    onDeselect: resetTextTransform,
    isShownByDefault: defaultControls.textTransform,
    panelId: panelId
  }, (0, _element.createElement)(_textTransformControl.default, {
    value: textTransform,
    onChange: setTextTransform,
    showNone: true,
    isBlock: true,
    size: "__unstable-large",
    __nextHasNoMarginBottom: true
  })));
}
//# sourceMappingURL=typography-panel.js.map