@wordpress/edit-site 6.31.1-next.f56bd8138.0 → 6.32.1-next.47f435fc9.0

package/build/components/global-styles/font-library-modal/context.js

@@ -1,147 +1,130 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  FontLibraryContext: () => FontLibraryContext,
+  default: () => context_default
 });
-exports.default = exports.FontLibraryContext = void 0;
-var _element = require("@wordpress/element");
-var _blockEditor = require("@wordpress/block-editor");
-var _data = require("@wordpress/data");
-var _coreData = require("@wordpress/core-data");
-var _i18n = require("@wordpress/i18n");
-var _resolvers = require("./resolvers");
-var _lockUnlock = require("../../../lock-unlock");
-var _utils = require("./utils");
-var _toggleFont = require("./utils/toggleFont");
-var _setNestedValue = _interopRequireDefault(require("../../../utils/set-nested-value"));
-var _jsxRuntime = require("react/jsx-runtime");
-/**
- * WordPress dependencies
- */
-
-/**
- * Internal dependencies
- */
-
-const {
-  useGlobalSetting
-} = (0, _lockUnlock.unlock)(_blockEditor.privateApis);
-const FontLibraryContext = exports.FontLibraryContext = (0, _element.createContext)({});
-FontLibraryContext.displayName = 'FontLibraryContext';
-function FontLibraryProvider({
-  children
-}) {
-  const {
-    saveEntityRecord
-  } = (0, _data.useDispatch)(_coreData.store);
-  const {
-    globalStylesId
-  } = (0, _data.useSelect)(select => {
-    const {
-      __experimentalGetCurrentGlobalStylesId
-    } = select(_coreData.store);
-    return {
-      globalStylesId: __experimentalGetCurrentGlobalStylesId()
-    };
+module.exports = __toCommonJS(context_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_element = require("@wordpress/element");
+var import_block_editor = require("@wordpress/block-editor");
+var import_data = require("@wordpress/data");
+var import_core_data = require("@wordpress/core-data");
+var import_i18n = require("@wordpress/i18n");
+var import_resolvers = require("./resolvers");
+var import_lock_unlock = require("../../../lock-unlock");
+var import_utils = require("./utils");
+var import_toggleFont = require("./utils/toggleFont");
+var import_set_nested_value = __toESM(require("../../../utils/set-nested-value"));
+const { useGlobalSetting } = (0, import_lock_unlock.unlock)(import_block_editor.privateApis);
+const FontLibraryContext = (0, import_element.createContext)({});
+FontLibraryContext.displayName = "FontLibraryContext";
+function FontLibraryProvider({ children }) {
+  const { saveEntityRecord } = (0, import_data.useDispatch)(import_core_data.store);
+  const { globalStylesId } = (0, import_data.useSelect)((select) => {
+    const { __experimentalGetCurrentGlobalStylesId } = select(import_core_data.store);
+    return { globalStylesId: __experimentalGetCurrentGlobalStylesId() };
   });
-  const globalStyles = (0, _coreData.useEntityRecord)('root', 'globalStyles', globalStylesId);
-  const [isInstalling, setIsInstalling] = (0, _element.useState)(false);
-  const [refreshKey, setRefreshKey] = (0, _element.useState)(0);
+  const globalStyles = (0, import_core_data.useEntityRecord)(
+    "root",
+    "globalStyles",
+    globalStylesId
+  );
+  const [isInstalling, setIsInstalling] = (0, import_element.useState)(false);
+  const [refreshKey, setRefreshKey] = (0, import_element.useState)(0);
   const refreshLibrary = () => {
     setRefreshKey(Date.now());
   };
-  const {
-    records: libraryPosts = [],
-    isResolving: isResolvingLibrary
-  } = (0, _coreData.useEntityRecords)('postType', 'wp_font_family', {
+  const { records: libraryPosts = [], isResolving: isResolvingLibrary } = (0, import_core_data.useEntityRecords)("postType", "wp_font_family", {
     refreshKey,
     _embed: true
   });
-  const libraryFonts = (libraryPosts || []).map(fontFamilyPost => {
+  const libraryFonts = (libraryPosts || []).map((fontFamilyPost) => {
     return {
       id: fontFamilyPost.id,
       ...fontFamilyPost.font_family_settings,
-      fontFace: fontFamilyPost?._embedded?.font_faces.map(face => face.font_face_settings) || []
+      fontFace: fontFamilyPost?._embedded?.font_faces.map(
+        (face) => face.font_face_settings
+      ) || []
     };
   }) || [];
-
-  // Global Styles (settings) font families
-  const [fontFamilies, setFontFamilies] = useGlobalSetting('typography.fontFamilies');
-
-  /*
-   * Save the font families to the database.
-  	 * This function is called when the user activates or deactivates a font family.
-   * It only updates the global styles post content in the database for new font families.
-   * This avoids saving other styles/settings changed by the user using other parts of the editor.
-   *
-   * It uses the font families from the param to avoid using the font families from an outdated state.
-   *
-   * @param {Array} fonts - The font families that will be saved to the database.
-   */
-  const saveFontFamilies = async fonts => {
-    // Gets the global styles database post content.
+  const [fontFamilies, setFontFamilies] = useGlobalSetting(
+    "typography.fontFamilies"
+  );
+  const saveFontFamilies = async (fonts) => {
     const updatedGlobalStyles = globalStyles.record;
-
-    // Updates the database version of global styles with the edited font families in the client.
-    (0, _setNestedValue.default)(updatedGlobalStyles, ['settings', 'typography', 'fontFamilies'], fonts);
-
-    // Saves a new version of the global styles in the database.
-    await saveEntityRecord('root', 'globalStyles', updatedGlobalStyles);
+    (0, import_set_nested_value.default)(
+      updatedGlobalStyles,
+      ["settings", "typography", "fontFamilies"],
+      fonts
+    );
+    await saveEntityRecord("root", "globalStyles", updatedGlobalStyles);
   };
-
-  // Library Fonts
-  const [modalTabOpen, setModalTabOpen] = (0, _element.useState)(false);
-  const [libraryFontSelected, setLibraryFontSelected] = (0, _element.useState)(null);
-
-  // Themes Fonts are the fonts defined in the global styles (database persisted theme.json data).
-  const themeFonts = fontFamilies?.theme ? fontFamilies.theme.map(f => (0, _utils.setUIValuesNeeded)(f, {
-    source: 'theme'
-  })).sort((a, b) => a.name.localeCompare(b.name)) : [];
-  const customFonts = fontFamilies?.custom ? fontFamilies.custom.map(f => (0, _utils.setUIValuesNeeded)(f, {
-    source: 'custom'
-  })).sort((a, b) => a.name.localeCompare(b.name)) : [];
-  const baseCustomFonts = libraryFonts ? libraryFonts.map(f => (0, _utils.setUIValuesNeeded)(f, {
-    source: 'custom'
-  })).sort((a, b) => a.name.localeCompare(b.name)) : [];
-  (0, _element.useEffect)(() => {
+  const [modalTabOpen, setModalTabOpen] = (0, import_element.useState)(false);
+  const [libraryFontSelected, setLibraryFontSelected] = (0, import_element.useState)(null);
+  const themeFonts = fontFamilies?.theme ? fontFamilies.theme.map((f) => (0, import_utils.setUIValuesNeeded)(f, { source: "theme" })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+  const customFonts = fontFamilies?.custom ? fontFamilies.custom.map((f) => (0, import_utils.setUIValuesNeeded)(f, { source: "custom" })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+  const baseCustomFonts = libraryFonts ? libraryFonts.map((f) => (0, import_utils.setUIValuesNeeded)(f, { source: "custom" })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+  (0, import_element.useEffect)(() => {
     if (!modalTabOpen) {
       setLibraryFontSelected(null);
     }
   }, [modalTabOpen]);
-  const handleSetLibraryFontSelected = font => {
-    // If font is null, reset the selected font
+  const handleSetLibraryFontSelected = (font) => {
     if (!font) {
       setLibraryFontSelected(null);
       return;
     }
-    const fonts = font.source === 'theme' ? themeFonts : baseCustomFonts;
-
-    // Tries to find the font in the installed fonts
-    const fontSelected = fonts.find(f => f.slug === font.slug);
-    // If the font is not found (it is only defined in custom styles), use the font from custom styles
+    const fonts = font.source === "theme" ? themeFonts : baseCustomFonts;
+    const fontSelected = fonts.find((f) => f.slug === font.slug);
     setLibraryFontSelected({
-      ...(fontSelected || font),
+      ...fontSelected || font,
       source: font.source
     });
   };
-
-  // Demo
-  const [loadedFontUrls] = (0, _element.useState)(new Set());
-  const getAvailableFontsOutline = availableFontFamilies => {
+  const [loadedFontUrls] = (0, import_element.useState)(/* @__PURE__ */ new Set());
+  const getAvailableFontsOutline = (availableFontFamilies) => {
     const outline = availableFontFamilies.reduce((acc, font) => {
-      const availableFontFaces = font?.fontFace && font.fontFace?.length > 0 ? font?.fontFace.map(face => `${face.fontStyle + face.fontWeight}`) : ['normal400']; // If the font doesn't have fontFace, we assume it is a system font and we add the defaults: normal 400
-
+      const availableFontFaces = font?.fontFace && font.fontFace?.length > 0 ? font?.fontFace.map(
+        (face) => `${face.fontStyle + face.fontWeight}`
+      ) : ["normal400"];
       acc[font.slug] = availableFontFaces;
       return acc;
     }, {});
     return outline;
   };
-  const getActivatedFontsOutline = source => {
+  const getActivatedFontsOutline = (source) => {
     switch (source) {
-      case 'theme':
+      case "theme":
         return getAvailableFontsOutline(themeFonts);
-      case 'custom':
+      case "custom":
       default:
         return getAvailableFontsOutline(customFonts);
     }
@@ -150,7 +133,9 @@ function FontLibraryProvider({
     if (!style && !weight) {
       return !!getActivatedFontsOutline(source)[slug];
     }
-    return !!getActivatedFontsOutline(source)[slug]?.includes(style + weight);
+    return !!getActivatedFontsOutline(source)[slug]?.includes(
+      style + weight
+    );
   };
   const getFontFacesActivated = (slug, source) => {
     return getActivatedFontsOutline(source)[slug] || [];
@@ -162,64 +147,70 @@ function FontLibraryProvider({
       let installationErrors = [];
       for (const fontFamilyToInstall of fontFamiliesToInstall) {
         let isANewFontFamily = false;
-
-        // Get the font family if it already exists.
-        let installedFontFamily = await (0, _resolvers.fetchGetFontFamilyBySlug)(fontFamilyToInstall.slug);
-
-        // Otherwise create it.
+        let installedFontFamily = await (0, import_resolvers.fetchGetFontFamilyBySlug)(
+          fontFamilyToInstall.slug
+        );
         if (!installedFontFamily) {
           isANewFontFamily = true;
-          // Prepare font family form data to install.
-          installedFontFamily = await (0, _resolvers.fetchInstallFontFamily)((0, _utils.makeFontFamilyFormData)(fontFamilyToInstall));
+          installedFontFamily = await (0, import_resolvers.fetchInstallFontFamily)(
+            (0, import_utils.makeFontFamilyFormData)(fontFamilyToInstall)
+          );
         }
-
-        // Collect font faces that have already been installed (to be activated later)
-        const alreadyInstalledFontFaces = installedFontFamily.fontFace && fontFamilyToInstall.fontFace ? installedFontFamily.fontFace.filter(fontFaceToInstall => (0, _utils.checkFontFaceInstalled)(fontFaceToInstall, fontFamilyToInstall.fontFace)) : [];
-
-        // Filter out Font Faces that have already been installed (so that they are not re-installed)
+        const alreadyInstalledFontFaces = installedFontFamily.fontFace && fontFamilyToInstall.fontFace ? installedFontFamily.fontFace.filter(
+          (fontFaceToInstall) => (0, import_utils.checkFontFaceInstalled)(
+            fontFaceToInstall,
+            fontFamilyToInstall.fontFace
+          )
+        ) : [];
         if (installedFontFamily.fontFace && fontFamilyToInstall.fontFace) {
-          fontFamilyToInstall.fontFace = fontFamilyToInstall.fontFace.filter(fontFaceToInstall => !(0, _utils.checkFontFaceInstalled)(fontFaceToInstall, installedFontFamily.fontFace));
+          fontFamilyToInstall.fontFace = fontFamilyToInstall.fontFace.filter(
+            (fontFaceToInstall) => !(0, import_utils.checkFontFaceInstalled)(
+              fontFaceToInstall,
+              installedFontFamily.fontFace
+            )
+          );
         }
-
-        // Install the fonts (upload the font files to the server and create the post in the database).
         let successfullyInstalledFontFaces = [];
         let unsuccessfullyInstalledFontFaces = [];
         if (fontFamilyToInstall?.fontFace?.length > 0) {
-          const response = await (0, _utils.batchInstallFontFaces)(installedFontFamily.id, (0, _utils.makeFontFacesFormData)(fontFamilyToInstall));
+          const response = await (0, import_utils.batchInstallFontFaces)(
+            installedFontFamily.id,
+            (0, import_utils.makeFontFacesFormData)(fontFamilyToInstall)
+          );
           successfullyInstalledFontFaces = response?.successes;
           unsuccessfullyInstalledFontFaces = response?.errors;
         }
-
-        // Use the successfully installed font faces
-        // As well as any font faces that were already installed (those will be activated)
         if (successfullyInstalledFontFaces?.length > 0 || alreadyInstalledFontFaces?.length > 0) {
-          // Use font data from REST API not from client to ensure
-          // correct font information is used.
-          installedFontFamily.fontFace = [...successfullyInstalledFontFaces];
+          installedFontFamily.fontFace = [
+            ...successfullyInstalledFontFaces
+          ];
           fontFamiliesToActivate.push(installedFontFamily);
         }
-
-        // If it's a system font but was installed successfully, activate it.
         if (installedFontFamily && !fontFamilyToInstall?.fontFace?.length) {
           fontFamiliesToActivate.push(installedFontFamily);
         }
-
-        // If the font family is new and is not a system font, delete it to avoid having font families without font faces.
         if (isANewFontFamily && fontFamilyToInstall?.fontFace?.length > 0 && successfullyInstalledFontFaces?.length === 0) {
-          await (0, _resolvers.fetchUninstallFontFamily)(installedFontFamily.id);
+          await (0, import_resolvers.fetchUninstallFontFamily)(installedFontFamily.id);
         }
-        installationErrors = installationErrors.concat(unsuccessfullyInstalledFontFaces);
+        installationErrors = installationErrors.concat(
+          unsuccessfullyInstalledFontFaces
+        );
       }
-      installationErrors = installationErrors.reduce((unique, item) => unique.includes(item.message) ? unique : [...unique, item.message], []);
+      installationErrors = installationErrors.reduce(
+        (unique, item) => unique.includes(item.message) ? unique : [...unique, item.message],
+        []
+      );
       if (fontFamiliesToActivate.length > 0) {
-        // Activate the font family (add the font family to the global styles).
-        const activeFonts = activateCustomFontFamilies(fontFamiliesToActivate);
-        // Save the global styles to the database.
+        const activeFonts = activateCustomFontFamilies(
+          fontFamiliesToActivate
+        );
         await saveFontFamilies(activeFonts);
         refreshLibrary();
       }
       if (installationErrors.length > 0) {
-        const installError = new Error((0, _i18n.__)('There was an error installing fonts.'));
+        const installError = new Error(
+          (0, import_i18n.__)("There was an error installing fonts.")
+        );
         installError.installationErrors = installationErrors;
         throw installError;
       }
@@ -229,173 +220,167 @@ function FontLibraryProvider({
   }
   async function uninstallFontFamily(fontFamilyToUninstall) {
     try {
-      // Uninstall the font family.
-      // (Removes the font files from the server and the posts from the database).
-      const uninstalledFontFamily = await (0, _resolvers.fetchUninstallFontFamily)(fontFamilyToUninstall.id);
-
-      // Deactivate the font family if delete request is successful
-      // (Removes the font family from the global styles).
+      const uninstalledFontFamily = await (0, import_resolvers.fetchUninstallFontFamily)(
+        fontFamilyToUninstall.id
+      );
       if (uninstalledFontFamily.deleted) {
-        const activeFonts = deactivateFontFamily(fontFamilyToUninstall);
-        // Save the global styles to the database.
+        const activeFonts = deactivateFontFamily(
+          fontFamilyToUninstall
+        );
         await saveFontFamilies(activeFonts);
       }
-
-      // Refresh the library (the library font families from database).
       refreshLibrary();
       return uninstalledFontFamily;
     } catch (error) {
-      // eslint-disable-next-line no-console
-      console.error(`There was an error uninstalling the font family:`, error);
+      console.error(
+        `There was an error uninstalling the font family:`,
+        error
+      );
       throw error;
     }
   }
-  const deactivateFontFamily = font => {
-    var _fontFamilies$font$so;
-    // If the user doesn't have custom fonts defined, include as custom fonts all the theme fonts
-    // We want to save as active all the theme fonts at the beginning
-    const initialCustomFonts = (_fontFamilies$font$so = fontFamilies?.[font.source]) !== null && _fontFamilies$font$so !== void 0 ? _fontFamilies$font$so : [];
-    const newCustomFonts = initialCustomFonts.filter(f => f.slug !== font.slug);
+  const deactivateFontFamily = (font) => {
+    const initialCustomFonts = fontFamilies?.[font.source] ?? [];
+    const newCustomFonts = initialCustomFonts.filter(
+      (f) => f.slug !== font.slug
+    );
     const activeFonts = {
       ...fontFamilies,
       [font.source]: newCustomFonts
     };
     setFontFamilies(activeFonts);
     if (font.fontFace) {
-      font.fontFace.forEach(face => {
-        (0, _utils.unloadFontFaceInBrowser)(face, 'all');
+      font.fontFace.forEach((face) => {
+        (0, import_utils.unloadFontFaceInBrowser)(face, "all");
       });
     }
     return activeFonts;
   };
-  const activateCustomFontFamilies = fontsToAdd => {
+  const activateCustomFontFamilies = (fontsToAdd) => {
     const fontsToActivate = cleanFontsForSave(fontsToAdd);
     const activeFonts = {
       ...fontFamilies,
       // Merge the existing custom fonts with the new fonts.
-      custom: (0, _utils.mergeFontFamilies)(fontFamilies?.custom, fontsToActivate)
+      custom: (0, import_utils.mergeFontFamilies)(fontFamilies?.custom, fontsToActivate)
     };
-
-    // Activate the fonts by set the new custom fonts array.
     setFontFamilies(activeFonts);
     loadFontsInBrowser(fontsToActivate);
     return activeFonts;
   };
-
-  // Removes the id from the families and faces to avoid saving that to global styles post content.
-  const cleanFontsForSave = fonts => {
-    return fonts.map(({
-      id: _familyDbId,
-      fontFace,
-      ...font
-    }) => ({
+  const cleanFontsForSave = (fonts) => {
+    return fonts.map(({ id: _familyDbId, fontFace, ...font }) => ({
       ...font,
-      ...(fontFace && fontFace.length > 0 ? {
-        fontFace: fontFace.map(({
-          id: _faceDbId,
-          ...face
-        }) => face)
-      } : {})
+      ...fontFace && fontFace.length > 0 ? {
+        fontFace: fontFace.map(
+          ({ id: _faceDbId, ...face }) => face
+        )
+      } : {}
     }));
   };
-  const loadFontsInBrowser = fonts => {
-    // Add custom fonts to the browser.
-    fonts.forEach(font => {
+  const loadFontsInBrowser = (fonts) => {
+    fonts.forEach((font) => {
       if (font.fontFace) {
-        font.fontFace.forEach(face => {
-          // Load font faces just in the iframe because they already are in the document.
-          (0, _utils.loadFontFaceInBrowser)(face, (0, _utils.getDisplaySrcFromFontFace)(face.src), 'all');
+        font.fontFace.forEach((face) => {
+          (0, import_utils.loadFontFaceInBrowser)(
+            face,
+            (0, import_utils.getDisplaySrcFromFontFace)(face.src),
+            "all"
+          );
         });
       }
     });
   };
   const toggleActivateFont = (font, face) => {
-    var _fontFamilies$font$so2;
-    // If the user doesn't have custom fonts defined, include as custom fonts all the theme fonts
-    // We want to save as active all the theme fonts at the beginning
-    const initialFonts = (_fontFamilies$font$so2 = fontFamilies?.[font.source]) !== null && _fontFamilies$font$so2 !== void 0 ? _fontFamilies$font$so2 : [];
-    // Toggles the received font family or font face
-    const newFonts = (0, _toggleFont.toggleFont)(font, face, initialFonts);
-    // Updates the font families activated in global settings:
+    const initialFonts = fontFamilies?.[font.source] ?? [];
+    const newFonts = (0, import_toggleFont.toggleFont)(font, face, initialFonts);
     setFontFamilies({
       ...fontFamilies,
       [font.source]: newFonts
     });
-    const isFaceActivated = isFontActivated(font.slug, face?.fontStyle, face?.fontWeight, font.source);
+    const isFaceActivated = isFontActivated(
+      font.slug,
+      face?.fontStyle,
+      face?.fontWeight,
+      font.source
+    );
     if (isFaceActivated) {
-      (0, _utils.unloadFontFaceInBrowser)(face, 'all');
+      (0, import_utils.unloadFontFaceInBrowser)(face, "all");
     } else {
-      (0, _utils.loadFontFaceInBrowser)(face, (0, _utils.getDisplaySrcFromFontFace)(face?.src), 'all');
+      (0, import_utils.loadFontFaceInBrowser)(
+        face,
+        (0, import_utils.getDisplaySrcFromFontFace)(face?.src),
+        "all"
+      );
     }
   };
-  const loadFontFaceAsset = async fontFace => {
-    // If the font doesn't have a src, don't load it.
+  const loadFontFaceAsset = async (fontFace) => {
     if (!fontFace.src) {
       return;
     }
-    // Get the src of the font.
-    const src = (0, _utils.getDisplaySrcFromFontFace)(fontFace.src);
-    // If the font is already loaded, don't load it again.
+    const src = (0, import_utils.getDisplaySrcFromFontFace)(fontFace.src);
     if (!src || loadedFontUrls.has(src)) {
       return;
     }
-    // Load the font in the browser.
-    (0, _utils.loadFontFaceInBrowser)(fontFace, src, 'document');
-    // Add the font to the loaded fonts list.
+    (0, import_utils.loadFontFaceInBrowser)(fontFace, src, "document");
     loadedFontUrls.add(src);
   };
-
-  // Font Collections
-  const [collections, setFontCollections] = (0, _element.useState)([]);
+  const [collections, setFontCollections] = (0, import_element.useState)([]);
   const getFontCollections = async () => {
-    const response = await (0, _resolvers.fetchFontCollections)();
+    const response = await (0, import_resolvers.fetchFontCollections)();
     setFontCollections(response);
   };
-  const getFontCollection = async slug => {
+  const getFontCollection = async (slug) => {
     try {
-      const hasData = !!collections.find(collection => collection.slug === slug)?.font_families;
+      const hasData = !!collections.find(
+        (collection) => collection.slug === slug
+      )?.font_families;
       if (hasData) {
         return;
       }
-      const response = await (0, _resolvers.fetchFontCollection)(slug);
-      const updatedCollections = collections.map(collection => collection.slug === slug ? {
-        ...collection,
-        ...response
-      } : collection);
+      const response = await (0, import_resolvers.fetchFontCollection)(slug);
+      const updatedCollections = collections.map(
+        (collection) => collection.slug === slug ? { ...collection, ...response } : collection
+      );
       setFontCollections(updatedCollections);
     } catch (e) {
-      // eslint-disable-next-line no-console
       console.error(e);
       throw e;
     }
   };
-  (0, _element.useEffect)(() => {
+  (0, import_element.useEffect)(() => {
     getFontCollections();
   }, []);
-  return /*#__PURE__*/(0, _jsxRuntime.jsx)(FontLibraryContext.Provider, {
-    value: {
-      libraryFontSelected,
-      handleSetLibraryFontSelected,
-      fontFamilies,
-      baseCustomFonts,
-      isFontActivated,
-      getFontFacesActivated,
-      loadFontFaceAsset,
-      installFonts,
-      uninstallFontFamily,
-      toggleActivateFont,
-      getAvailableFontsOutline,
-      modalTabOpen,
-      setModalTabOpen,
-      refreshLibrary,
-      saveFontFamilies,
-      isResolvingLibrary,
-      isInstalling,
-      collections,
-      getFontCollection
-    },
-    children: children
-  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    FontLibraryContext.Provider,
+    {
+      value: {
+        libraryFontSelected,
+        handleSetLibraryFontSelected,
+        fontFamilies,
+        baseCustomFonts,
+        isFontActivated,
+        getFontFacesActivated,
+        loadFontFaceAsset,
+        installFonts,
+        uninstallFontFamily,
+        toggleActivateFont,
+        getAvailableFontsOutline,
+        modalTabOpen,
+        setModalTabOpen,
+        refreshLibrary,
+        saveFontFamilies,
+        isResolvingLibrary,
+        isInstalling,
+        collections,
+        getFontCollection
+      },
+      children
+    }
+  );
 }
-var _default = exports.default = FontLibraryProvider;
-//# sourceMappingURL=context.js.map
+var context_default = FontLibraryProvider;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FontLibraryContext
+});
+//# sourceMappingURL=context.js.map