@imposium-hub/components 1.56.0 → 1.57.0

package/dist/cjs/components/font-picker/FontPicker.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import FontManager from './font-manager/FontManager';
+import { Category, Font, Script, Variant } from './font-manager/types';
+interface IFontPickerProps {
+    apiKey: string;
+    activeFontFamily: string;
+    onChange: (font: string) => void;
+    families: string[];
+    categories: Category[];
+    scripts: Script[];
+    variants: Variant[];
+    filter: (font: Font) => boolean;
+    limit: number;
+    defaultFonts: any;
+    customFonts?: any;
+}
+interface IFontPickerState {
+    expanded: boolean;
+    fonts: any;
+}
+export default class FontPicker extends React.PureComponent<IFontPickerProps, IFontPickerState> {
+    fontManager: FontManager;
+    static defaultProps: {
+        activeFontFamily: string;
+        families: string[];
+        categories: Category[];
+        scripts: Script[];
+        variants: Variant[];
+        filter: (font: Font) => boolean;
+        limit: number;
+    };
+    private clickOutsideHandler;
+    constructor(props: any);
+    compoenntDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate: (prevProps: any) => void;
+    private onClose;
+    private onSelection;
+    private setActiveFontFamily;
+    private generateFontList;
+    private toggleExpanded;
+    render: () => JSX.Element;
+}
+export {};

package/dist/cjs/components/font-picker/FontPicker.js

@@ -0,0 +1,182 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var React = __importStar(require("react"));
+var FontManager_1 = __importDefault(require("./font-manager/FontManager"));
+var types_1 = require("./font-manager/types");
+var constants_1 = require("./font-manager/constants");
+var fontStyle_1 = require("./font-manager/fontStyle");
+var FontPicker = /** @class */ (function (_super) {
+    __extends(FontPicker, _super);
+    function FontPicker(props) {
+        var _this = _super.call(this, props) || this;
+        _this.componentDidUpdate = function (prevProps) {
+            var _a = _this.props, activeFontFamily = _a.activeFontFamily, onChange = _a.onChange, customFonts = _a.customFonts, defaultFonts = _a.defaultFonts;
+            if (prevProps.customFonts !== customFonts) {
+                _this.fontManager
+                    .init()
+                    .then(function (fontMap) {
+                    var googleFonts = Array.from(fontMap.values()).filter(function (f) { return f.files; });
+                    var updateDefaultFonts = defaultFonts.map(function (f) { return googleFonts.find(function (o) { return o.family === f.family; }) || f; });
+                    var uniqueFontFamilies = new Set();
+                    var uniqueFonts = updateDefaultFonts.filter(function (e) {
+                        var isDup = uniqueFontFamilies.has(e.family);
+                        uniqueFontFamilies.add(e.family);
+                        if (!isDup) {
+                            return true;
+                        }
+                        return false;
+                    });
+                    _this.setState({ fonts: uniqueFonts }, function () {
+                        return (0, fontStyle_1.createFontStyleSheets)(defaultFonts, uniqueFonts, customFonts);
+                    });
+                })
+                    .catch(function (err) {
+                    console.error('Error trying to fetch the list of available fonts');
+                    console.error(err);
+                });
+            }
+            if (activeFontFamily !== prevProps.activeFontFamily) {
+                _this.setActiveFontFamily(activeFontFamily);
+            }
+            if (onChange !== prevProps.onChange) {
+                _this.fontManager.setOnChange(onChange);
+            }
+        };
+        _this.onClose = function (e) {
+            var targetEl = e.target;
+            var fontPickerEl = document.getElementById("font-picker");
+            while (true) {
+                if (targetEl === fontPickerEl) {
+                    return;
+                }
+                if (targetEl.parentNode) {
+                    targetEl = targetEl.parentNode;
+                }
+                else {
+                    _this.toggleExpanded();
+                    return;
+                }
+            }
+        };
+        _this.onSelection = function (e) {
+            var activeFontFamily = e.target.textContent;
+            if (!activeFontFamily) {
+                throw Error("Missing font family in clicked font button");
+            }
+            _this.setActiveFontFamily(activeFontFamily);
+            _this.toggleExpanded();
+        };
+        _this.setActiveFontFamily = function (activeFontFamily) {
+            _this.fontManager.setActiveFont(activeFontFamily);
+        };
+        _this.generateFontList = function () {
+            var _a = _this.props, activeFontFamily = _a.activeFontFamily, families = _a.families;
+            return (React.createElement("ul", { className: 'font-list' }, families.map(function (font) {
+                var isActive = font === activeFontFamily;
+                return (React.createElement("li", { key: font, className: 'font-list-item' },
+                    React.createElement("button", { type: 'button', id: "font-button-".concat(font), className: "font-button ".concat(isActive ? 'active-font' : ''), onClick: _this.onSelection, onKeyDown: _this.onSelection, style: { fontFamily: font } }, font)));
+            })));
+        };
+        _this.toggleExpanded = function () {
+            var expanded = _this.state.expanded;
+            if (expanded) {
+                _this.setState({
+                    expanded: false
+                });
+                document.removeEventListener('click', _this.clickOutsideHandler);
+            }
+            else {
+                _this.setState({
+                    expanded: true
+                });
+                document.addEventListener('click', _this.clickOutsideHandler);
+            }
+        };
+        _this.render = function () {
+            var activeFontFamily = _this.props.activeFontFamily;
+            var expanded = _this.state.expanded;
+            return (React.createElement("div", { id: "font-picker", className: expanded ? 'expanded' : '' },
+                React.createElement("button", { type: 'button', className: 'dropdown-button', onClick: _this.toggleExpanded, onKeyDown: _this.toggleExpanded },
+                    React.createElement("p", { className: 'dropdown-font-family' }, activeFontFamily),
+                    React.createElement("p", { className: 'dropdown-icon finished' })),
+                _this.generateFontList()));
+        };
+        var _a = _this.props, apiKey = _a.apiKey, activeFontFamily = _a.activeFontFamily, families = _a.families, categories = _a.categories, scripts = _a.scripts, variants = _a.variants, filter = _a.filter, limit = _a.limit, onChange = _a.onChange;
+        _this.state = {
+            expanded: false,
+            fonts: null
+        };
+        var options = {
+            families: families,
+            categories: categories,
+            scripts: scripts,
+            variants: variants,
+            filter: filter,
+            limit: limit
+        };
+        _this.fontManager = new FontManager_1.default(apiKey, activeFontFamily, options, onChange);
+        return _this;
+    }
+    FontPicker.prototype.compoenntDidMount = function () {
+        var _this = this;
+        this.clickOutsideHandler = function (e) { return _this.onClose(e); };
+    };
+    FontPicker.prototype.componentWillUnmount = function () {
+        this.clickOutsideHandler = function (e) {
+            return;
+        };
+    };
+    FontPicker.defaultProps = {
+        activeFontFamily: constants_1.FONT_FAMILY_DEFAULT,
+        families: types_1.OPTIONS_DEFAULTS.families,
+        categories: types_1.OPTIONS_DEFAULTS.categories,
+        scripts: types_1.OPTIONS_DEFAULTS.scripts,
+        variants: types_1.OPTIONS_DEFAULTS.variants,
+        filter: types_1.OPTIONS_DEFAULTS.filter,
+        limit: types_1.OPTIONS_DEFAULTS.limit
+    };
+    return FontPicker;
+}(React.PureComponent));
+exports.default = FontPicker;
+//# sourceMappingURL=FontPicker.js.map

package/dist/cjs/components/font-picker/FontPicker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontPicker.js","sourceRoot":"","sources":["../../../../src/components/font-picker/FontPicker.tsx"],"names":[],"mappings":"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"}

package/dist/cjs/components/font-picker/font-manager/FontManager.d.ts

@@ -0,0 +1,26 @@
+import { FontList, Options } from './types';
+export default class FontManager {
+    private readonly apiKey;
+    private readonly options;
+    private onChange;
+    private fonts;
+    constructor(apiKey: string, defaultFamily: string, { families, categories, scripts, variants, filter, limit }: Options, onChange: (font: string) => void);
+    /**
+     * Fetch list of all fonts from Google Fonts API, filter it according to the class parameters and
+     * save them to the font map
+     */
+    init(): Promise<FontList>;
+    private getFontList;
+    /**
+     * Add a new font to the font map and download its preview characters
+     */
+    private addFont;
+    /**
+     * Set the specified font as the active font and download it
+     */
+    setActiveFont(fontFamily: string): void;
+    /**
+     * Update the onChange function (executed when changing the active font)
+     */
+    setOnChange(onChange: (font: string) => void): void;
+}

package/dist/cjs/components/font-picker/font-manager/FontManager.js

@@ -0,0 +1,209 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = require("./types");
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+var FontManager = /** @class */ (function () {
+    function FontManager(apiKey, defaultFamily, _a, onChange) {
+        if (defaultFamily === void 0) { defaultFamily = constants_1.FONT_FAMILY_DEFAULT; }
+        var _b = _a.families, families = _b === void 0 ? types_1.OPTIONS_DEFAULTS.families : _b, _c = _a.categories, categories = _c === void 0 ? types_1.OPTIONS_DEFAULTS.categories : _c, _d = _a.scripts, scripts = _d === void 0 ? types_1.OPTIONS_DEFAULTS.scripts : _d, _e = _a.variants, variants = _e === void 0 ? types_1.OPTIONS_DEFAULTS.variants : _e, _f = _a.filter, filter = _f === void 0 ? types_1.OPTIONS_DEFAULTS.filter : _f, _g = _a.limit, limit = _g === void 0 ? types_1.OPTIONS_DEFAULTS.limit : _g;
+        this.fonts = new Map();
+        // Save parameters as class variables
+        this.apiKey = apiKey;
+        this.options = {
+            families: families,
+            categories: categories,
+            scripts: scripts,
+            variants: variants,
+            filter: filter,
+            limit: limit
+        };
+        this.onChange = onChange;
+        // Download default font and add it to the empty font list
+        this.addFont(defaultFamily);
+        this.setActiveFont(defaultFamily);
+    }
+    /**
+     * Fetch list of all fonts from Google Fonts API, filter it according to the class parameters and
+     * save them to the font map
+     */
+    FontManager.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var fonts, _loop_1, this_1, fonts_1, fonts_1_1, font, state_1;
+            var e_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getFontList(this.apiKey)];
+                    case 1:
+                        fonts = _b.sent();
+                        _loop_1 = function (font) {
+                            // const font = fonts[i];
+                            // Exit once specified limit of number of fonts is reached
+                            if (this_1.fonts.size >= this_1.options.limit) {
+                                return "break";
+                            }
+                            if (
+                            // Skip default font if it is also contained in the list
+                            !this_1.fonts.has(font.family) &&
+                                // `families` parameter: Only keep fonts whose names are included in the provided array
+                                (this_1.options.families.length === 0 ||
+                                    this_1.options.families.includes(font.family)) &&
+                                // `categories` parameter: only keep fonts in categories from the provided array
+                                (this_1.options.categories.length === 0 ||
+                                    this_1.options.categories.includes(font.category)) &&
+                                // `scripts` parameter: Only keep fonts which are available in all specified scripts
+                                this_1.options.scripts.every(function (script) { return font.scripts.includes(script); }) &&
+                                // `variants` parameter: Only keep fonts which contain all specified variants
+                                this_1.options.variants.every(function (variant) {
+                                    return font.variants.includes(variant);
+                                }) &&
+                                // `filter` parameter: Only keep fonts for which the `filter` function evaluates to `true`
+                                this_1.options.filter(font) === true) {
+                                // Font fulfils all requirements: Add it to font map
+                                this_1.fonts.set(font.family, font);
+                            }
+                        };
+                        this_1 = this;
+                        try {
+                            // Save desired fonts in the font map
+                            for (fonts_1 = __values(fonts), fonts_1_1 = fonts_1.next(); !fonts_1_1.done; fonts_1_1 = fonts_1.next()) {
+                                font = fonts_1_1.value;
+                                state_1 = _loop_1(font);
+                                if (state_1 === "break")
+                                    break;
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (fonts_1_1 && !fonts_1_1.done && (_a = fonts_1.return)) _a.call(fonts_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return [2 /*return*/, this.fonts];
+                }
+            });
+        });
+    };
+    FontManager.prototype.getFontList = function (apiKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, fontsOriginal;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = new URL(constants_1.LIST_BASE_URL);
+                        url.searchParams.append('sort', 'popularity');
+                        url.searchParams.append('key', apiKey);
+                        return [4 /*yield*/, (0, utils_1.get)(url.href)];
+                    case 1:
+                        response = _a.sent();
+                        fontsOriginal = JSON.parse(response).items;
+                        return [2 /*return*/, fontsOriginal.map(function (fontOriginal) {
+                                var family = fontOriginal.family, subsets = fontOriginal.subsets, others = __rest(fontOriginal, ["family", "subsets"]);
+                                return __assign(__assign({}, others), { family: family, id: (0, utils_1.getFontId)(family), scripts: subsets });
+                            })];
+                }
+            });
+        });
+    };
+    /**
+     * Add a new font to the font map and download its preview characters
+     */
+    FontManager.prototype.addFont = function (fontFamily) {
+        var font = {
+            family: fontFamily,
+            id: (0, utils_1.getFontId)(fontFamily),
+            variants: [],
+            category: 'display',
+            scripts: []
+        };
+        this.fonts.set(fontFamily, font);
+    };
+    /**
+     * Set the specified font as the active font and download it
+     */
+    FontManager.prototype.setActiveFont = function (fontFamily) {
+        var runOnChange = fontFamily !== 'Font not found';
+        if (runOnChange) {
+            this.onChange(fontFamily);
+        }
+    };
+    /**
+     * Update the onChange function (executed when changing the active font)
+     */
+    FontManager.prototype.setOnChange = function (onChange) {
+        this.onChange = onChange;
+    };
+    return FontManager;
+}());
+exports.default = FontManager;
+//# sourceMappingURL=FontManager.js.map

package/dist/cjs/components/font-picker/font-manager/FontManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontManager.js","sourceRoot":"","sources":["../../../../../src/components/font-picker/font-manager/FontManager.ts"],"names":[],"mappings":"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"}

package/dist/cjs/components/font-picker/font-manager/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const FONT_BASE_URL = "https://fonts.googleapis.com/css2";
+export declare const LIST_BASE_URL = "https://www.googleapis.com/webfonts/v1/webfonts";
+export declare const FONT_FACE_REGEX: RegExp;
+export declare const FONT_FAMILY_DEFAULT = "Open Sans";

package/dist/cjs/components/font-picker/font-manager/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FONT_FAMILY_DEFAULT = exports.FONT_FACE_REGEX = exports.LIST_BASE_URL = exports.FONT_BASE_URL = void 0;
+exports.FONT_BASE_URL = 'https://fonts.googleapis.com/css2';
+exports.LIST_BASE_URL = 'https://www.googleapis.com/webfonts/v1/webfonts';
+exports.FONT_FACE_REGEX = /@font-face {([\s\S]*?)}/gm;
+exports.FONT_FAMILY_DEFAULT = 'Open Sans';
+//# sourceMappingURL=constants.js.map

package/dist/cjs/components/font-picker/font-manager/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../src/components/font-picker/font-manager/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,aAAa,GAAG,mCAAmC,CAAC;AAEpD,QAAA,aAAa,GAAG,iDAAiD,CAAC;AAElE,QAAA,eAAe,GAAG,2BAA2B,CAAC;AAE9C,QAAA,mBAAmB,GAAG,WAAW,CAAC"}

package/dist/cjs/components/font-picker/font-manager/fontStyle.d.ts

@@ -0,0 +1 @@
+export declare const createFontStyleSheets: (defaultFonts: any, uniqueFonts: any, availableFonts?: any) => void;

package/dist/cjs/components/font-picker/font-manager/fontStyle.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFontStyleSheets = void 0;
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+var createFontStyleSheets = function (defaultFonts, uniqueFonts, availableFonts) {
+    defaultFonts.map(function (font) {
+        var fonts = uniqueFonts.find(function (f) { return f.family === font.family; });
+        var fontId = font.name.toLowerCase().split(' ').join('-');
+        // non Google Font style
+        if (fonts === null || fonts === void 0 ? void 0 : fonts.file) {
+            fillFontStyleSheets(fontId, font);
+        }
+        // google font style
+        if (fonts === null || fonts === void 0 ? void 0 : fonts.files) {
+            var fontURL = new URL(constants_1.FONT_BASE_URL);
+            fontURL.searchParams.append('family', "".concat(font.family, ":wght@").concat(font.weight));
+            fontURL.searchParams.append('text', font.name);
+            fontURL.searchParams.append('font-display', 'swap');
+            (0, utils_1.get)(fontURL.href)
+                .then(function (res) {
+                var rule = (0, utils_1.getMatches)(constants_1.FONT_FACE_REGEX, res);
+                var updateFont = rule[rule.length - 1].replace(font.family, font.name);
+                fillFontStyleSheets(fontId, updateFont, font.name);
+            })
+                .catch(function (e) { return console.error(e); });
+        }
+    });
+    // custom font style
+    if (availableFonts) {
+        availableFonts.map(function (font) {
+            var fontId = font.name.toLowerCase();
+            fillFontStyleSheets(fontId, font);
+        });
+    }
+};
+exports.createFontStyleSheets = createFontStyleSheets;
+var fillFontStyleSheets = function (fontId, font, fontName) {
+    var stylesheetNode = document.getElementById("font-".concat(fontId));
+    var weight = font.weight, file = font.file, url = font.url, name = font.name, family = font.family;
+    var fontFamily = name !== family ? name : family;
+    var fontWeight = weight ? "font-weight: ".concat(weight, ";") : '';
+    var fontUrl = file ? "fonts/".concat(file) : "".concat(url);
+    if (stylesheetNode === null) {
+        stylesheetNode = stylesheetNode;
+        stylesheetNode = document.createElement('style');
+        if (stylesheetNode !== null) {
+            stylesheetNode.id = "font-".concat(fontId);
+            stylesheetNode.setAttribute('data-is-preview', 'true');
+            // non-google and custom fonts style
+            if (fontFamily && fontFamily && fontUrl) {
+                stylesheetNode.textContent = "\n                @font-face {\n                    font-family: ".concat(fontFamily, ";\n                    ").concat(fontWeight, "\n                    src: url(").concat(fontUrl, ");\n                }");
+            }
+            if (fontName) {
+                stylesheetNode.textContent = "\n                @font-face {\n                    ".concat(font.replace("'".concat(fontName, "'"), fontName), "\n                }");
+            }
+            document.head.appendChild(stylesheetNode);
+        }
+    }
+};
+//# sourceMappingURL=fontStyle.js.map

package/dist/cjs/components/font-picker/font-manager/fontStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontStyle.js","sourceRoot":"","sources":["../../../../../src/components/font-picker/font-manager/fontStyle.ts"],"names":[],"mappings":"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"}

package/dist/cjs/components/font-picker/font-manager/types.d.ts

@@ -0,0 +1,25 @@
+export declare type Category = 'sans-serif' | 'serif' | 'display' | 'handwriting' | 'monospace';
+export declare type Script = 'arabic' | 'bengali' | 'chinese-simplified' | 'chinese-traditional' | 'cyrillic' | 'cyrillic-ext' | 'devanagari' | 'greek' | 'greek-ext' | 'gujarati' | 'gurmukhi' | 'hebrew' | 'japanese' | 'kannada' | 'khmer' | 'korean' | 'latin' | 'latin-ext' | 'malayalam' | 'myanmar' | 'oriya' | 'sinhala' | 'tamil' | '​telugu' | 'thai' | 'vietnamese';
+export declare type SortOption = 'alphabet' | 'popularity';
+export declare type Variant = '100' | '100italic' | '200' | '200italic' | '300' | '300italic' | 'regular' | 'italic' | '500' | '500italic' | '600' | '600italic' | '700' | '700italic' | '800' | '800italic' | '900' | '900italic';
+export interface Font {
+    family: string;
+    id: string;
+    category: Category;
+    scripts: Script[];
+    variants: Variant[];
+    kind?: string;
+    version?: string;
+    lastModified?: string;
+    files?: Record<Variant, string>;
+}
+export declare type FontList = Map<string, Font>;
+export interface Options {
+    families: string[];
+    categories: Category[];
+    scripts: Script[];
+    variants: Variant[];
+    filter: (font: Font) => boolean;
+    limit: number;
+}
+export declare const OPTIONS_DEFAULTS: Options;

package/dist/cjs/components/font-picker/font-manager/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTIONS_DEFAULTS = void 0;
+exports.OPTIONS_DEFAULTS = {
+    families: [],
+    categories: [],
+    scripts: ['latin'],
+    variants: ['regular'],
+    filter: function () { return true; },
+    limit: 50
+};
+//# sourceMappingURL=types.js.map

package/dist/cjs/components/font-picker/font-manager/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/components/font-picker/font-manager/types.ts"],"names":[],"mappings":";;;AA2Ea,QAAA,gBAAgB,GAAY;IACrC,QAAQ,EAAE,EAAE;IACZ,UAAU,EAAE,EAAE;IACd,OAAO,EAAE,CAAC,OAAO,CAAC;IAClB,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,MAAM,EAAE,cAAM,OAAA,IAAI,EAAJ,CAAI;IAClB,KAAK,EAAE,EAAE;CACZ,CAAC"}

package/dist/cjs/components/font-picker/font-manager/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const getFontId: (fontFamily: string) => string;
+export declare const get: (url: string) => Promise<string>;
+export declare const getMatches: (regex: RegExp, str: string) => string[];