@qooxdoo/framework 7.5.0 → 7.6.0

package/source/class/qx/tool/compiler/resources/ImageLoader.js

@@ -27,8 +27,13 @@ var log = qx.tool.utils.LogManager.createLog("resource-manager");
 qx.Class.define("qx.tool.compiler.resources.ImageLoader", {
   extend: qx.tool.compiler.resources.ResourceLoader,
 
-  construct() {
-    super([".png", ".gif", ".jpg", ".jpeg", ".svg"]);
+  /**
+   * Constructor
+   *
+   * @param {qx.tool.compiler.resources.Manager} manager resource manager
+   */
+  construct(manager) {
+    super([".png", ".gif", ".jpg", ".jpeg", ".svg"], manager);
   },
 
   members: {
@@ -50,16 +55,18 @@ qx.Class.define("qx.tool.compiler.resources.ImageLoader", {
      * @Override
      */
     matches(filename, library) {
-      if (filename.endsWith("svg")) {
-        let isWebFont =
-          library.getWebFonts() &&
-          library
-            .getWebFonts()
-            .find(webFont =>
-              webFont.getResources().find(resource => resource == filename)
-            );
+      if (library.isFontAsset(filename)) {
+        return false;
+      }
 
-        if (isWebFont) {
+      if (filename.endsWith(".svg")) {
+        let withoutExt = filename.substring(0, filename.length - 3);
+        let manager = this.getManager();
+        if (
+          ["eot", "woff2", "woff", "ttf"].find(
+            ext => !!manager.findLibraryForResource(withoutExt + ext)
+          )
+        ) {
           return false;
         }
       }
@@ -79,7 +86,10 @@ qx.Class.define("qx.tool.compiler.resources.ImageLoader", {
         fileInfo.width = dimensions.width;
         fileInfo.height = dimensions.height;
       } catch (ex) {
-        log.warn("Cannot get image size of " + filename + ": " + ex);
+        // When we can't get the image size, we don't report it because there are SVG types
+        //  that have no size (eg fonts) and it's proved quite hard (or impossible) to
+        //  suppress the warning accurately in those cases.  Ultimately, if the image is
+        //  corrupt it will be found.
         delete fileInfo.width;
         delete fileInfo.height;
       }

package/source/class/qx/tool/compiler/resources/Manager.js

@@ -43,8 +43,8 @@ qx.Class.define("qx.tool.compiler.resources.Manager", {
     this.__analyser = analyser;
     this.__dbFilename = analyser.getResDbFilename() || "resource-db.json";
     this.__loaders = [
-      new qx.tool.compiler.resources.ImageLoader(),
-      new qx.tool.compiler.resources.MetaLoader()
+      new qx.tool.compiler.resources.ImageLoader(this),
+      new qx.tool.compiler.resources.MetaLoader(this)
     ];
 
     this.__converters = [

package/source/class/qx/tool/compiler/resources/MetaLoader.js

@@ -23,8 +23,13 @@
 qx.Class.define("qx.tool.compiler.resources.MetaLoader", {
   extend: qx.tool.compiler.resources.ResourceLoader,
 
-  construct() {
-    super(".meta");
+  /**
+   * Constructor
+   *
+   * @param {qx.tool.compiler.resources.Manager} manager resource manager
+   */
+  construct(manager) {
+    super(".meta", manager);
   },
 
   members: {

package/source/class/qx/tool/compiler/resources/ResourceLoader.js

@@ -28,7 +28,21 @@ qx.Class.define("qx.tool.compiler.resources.ResourceLoader", {
   extend: qx.tool.compiler.resources.AbstractMatcher,
   type: "abstract",
 
+  /**
+   * Constructor
+   *
+   * @param {String} match the match for the filename
+   * @param {qx.tool.compiler.resources.Manager} manager resource manager
+   */
+  construct(match, manager) {
+    super(match);
+    this.__manager = manager;
+  },
+
   members: {
+    /** @type{qx.tool.compiler.resources.Manager} the resource manager this loader belongs to */
+    __manager: null,
+
     /**
      * Detects whether the file needs to be recompiled/coverted/analysed/ etc; this should
      * not take any time or be asynchronous, if you need to do any real work it should be
@@ -56,6 +70,13 @@ qx.Class.define("qx.tool.compiler.resources.ResourceLoader", {
      */
     async load(asset) {
       throw new Error("No implementation for " + this.classname + ".compile");
+    },
+
+    /**
+     * @return {qx.tool.compiler.resources.Manager} the manager
+     */
+    getManager() {
+      return this.__manager;
     }
   }
 });

package/source/class/qx/tool/compiler/targets/Target.js

@@ -106,6 +106,22 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       check: "Boolean"
     },
 
+    /**
+     * Whether to prefer local fonts instead of CDNs
+     */
+    preferLocalFonts: {
+      init: false,
+      check: "Boolean"
+    },
+
+    /**
+     * Types of fonts to be included
+     */
+    fontTypes: {
+      init: ["woff"],
+      check: "Array"
+    },
+
     /**
      * Whether to add timestamps to all URLs (cache busting)
      */
@@ -442,7 +458,7 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
         bootPackage.addJavascriptMeta(
           new qx.tool.compiler.targets.meta.Browserify(appMeta)
         );
-      }	
+      }
 
       /*
        * Assemble the Parts
@@ -506,12 +522,10 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       var assetUris = application.getAssetUris(t, rm, appMeta.getEnvironment()); // Save any changes that getAssets collected
       await rm.saveDatabase();
 
-      var promises = [
-        analyser.getCldr("en").then(cldr => bootPackage.addLocale("C", cldr)),
-        t._writeTranslations()
-      ];
+      let cldr = await analyser.getCldr("en");
+      await bootPackage.addLocale("C", cldr);
+      await this._writeTranslations();
 
-      var fontCntr = 0;
       var assets = {};
       rm.getAssetsForPaths(assetUris).forEach(asset => {
         bootPackage.addAsset(asset);
@@ -519,75 +533,180 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       });
 
       if (analyser.getApplicationTypes().indexOf("browser") > -1) {
-        // Get a list of all fonts to load; use the font name as a unique identifier, and
-        //  prioritise the application's library's definitions - this allows the application
-        //  the opportunity to override the font definitions.  This is important when the
-        //  library uses the open source/free versions of a font but the application
-        //  developer has purchased the commercial/full version of the font (eg FontAwesome)
-        let appLibrary = appMeta.getAppLibrary();
-        let fontsToLoad = {};
-        const addLibraryFonts = library => {
-          var fonts = library.getWebFonts();
-          if (!fonts) {
-            return;
-          }
-          fonts.forEach(font => {
-            fontsToLoad[font.getName()] = {
-              font,
-              library
-            };
-          });
-        };
-        requiredLibs.forEach(libnamespace => {
-          var library = analyser.findLibrary(libnamespace);
-          if (library != appLibrary) {
-            addLibraryFonts(library);
-          }
-        });
-        addLibraryFonts(appLibrary);
-
-        const loadFont = async (library, font) => {
-          try {
-            // check if font is asset somewhere
-            let res = font.getResources().filter(res => assets[res]);
-            if (res.length === 0) {
-              qx.tool.compiler.Console.print(
-                "qx.tool.compiler.webfonts.noResources",
-                font.toString(),
-                application.getName(),
-                font.getResources().join(",")
-              );
+        appMeta.addPreBootCode("qx.$$fontBootstrap={};\n");
+        await this.__writeDeprecatedWebFonts(application, appMeta, assets);
+        await this.__writeManifestFonts(
+          application,
+          appMeta,
+          assets,
+          bootPackage
+        );
+      }
+      await this._writeApplication();
+      this.__appMeta = null;
+    },
 
-              return;
-            }
-            font.setResources(res);
+    /**
+     * Writes the fonts defined in provides.webfonts
+     * @deprecated
+     */
+    async __writeDeprecatedWebFonts(application, appMeta, assets) {
+      let analyser = application.getAnalyser();
+      const requiredLibs = application.getRequiredLibraries();
 
-            await font.generateForTarget(t);
-            let resources = await font.generateForApplication(t, application);
-            for (var key in resources) {
-              appMeta.addResource(key, resources[key]);
-            }
-            var code = font.getBootstrapCode(t, application, fontCntr++ == 0);
-            if (code) {
-              appMeta.addPreBootCode(code);
-            }
-          } catch (ex) {
+      // Get a list of all fonts to load; use the font name as a unique identifier, and
+      //  prioritise the application's library's definitions - this allows the application
+      //  the opportunity to override the font definitions.  This is important when the
+      //  library uses the open source/free versions of a font but the application
+      //  developer has purchased the commercial/full version of the font (eg FontAwesome)
+      let appLibrary = appMeta.getAppLibrary();
+      let fontsToLoad = {};
+      const addLibraryFonts = library => {
+        var fonts = library.getWebFonts();
+        if (!fonts) {
+          return;
+        }
+        fonts.forEach(font => {
+          fontsToLoad[font.getName()] = {
+            font,
+            library
+          };
+        });
+      };
+      requiredLibs.forEach(libnamespace => {
+        var library = analyser.findLibrary(libnamespace);
+        if (library != appLibrary) {
+          addLibraryFonts(library);
+        }
+      });
+      addLibraryFonts(appLibrary);
+
+      const loadFont = async (library, font) => {
+        try {
+          // check if font is asset somewhere
+          let res = font.getResources().filter(res => assets[res]);
+          if (res.length === 0) {
             qx.tool.compiler.Console.print(
-              "qx.tool.compiler.webfonts.error",
+              "qx.tool.compiler.webfonts.noResources",
               font.toString(),
-              ex.toString()
+              application.getName(),
+              font.getResources().join(",")
             );
+
+            return;
           }
-        };
+          font.setResources(res);
 
-        Object.keys(fontsToLoad).forEach(fontName => {
-          let { font, library } = fontsToLoad[fontName];
-          promises.push(loadFont(library, font));
-        });
+          await font.generateForTarget(this);
+          let resources = await font.generateForApplication(this, application);
+          for (var key in resources) {
+            appMeta.addResource(key, resources[key]);
+          }
+          var code = font.getBootstrapCode(this, application);
+          if (code) {
+            appMeta.addPreBootCode(code);
+          }
+        } catch (ex) {
+          qx.tool.compiler.Console.print(
+            "qx.tool.compiler.webfonts.error",
+            font.toString(),
+            ex.toString()
+          );
+        }
+      };
+
+      for (let fontName of Object.keys(fontsToLoad)) {
+        let { font, library } = fontsToLoad[fontName];
+        await loadFont(library, font);
+      }
+    },
+
+    /**
+     * Writes the fonts defined in provides.fonts
+     */
+    async __writeManifestFonts(application, appMeta, assets, bootPackage) {
+      let analyser = application.getAnalyser();
+      let rm = analyser.getResourceManager();
+
+      const addResourcesToBuild = resourcePaths => {
+        for (let asset of rm.getAssetsForPaths(resourcePaths)) {
+          bootPackage.addAsset(asset);
+          assets[asset.getFilename()] = asset.toString();
+        }
+      };
+
+      let fontNames = application.getFonts();
+      for (let fontName of fontNames) {
+        let font = analyser.getFont(fontName);
+        if (!font) {
+          return;
+        }
+        let resources = font.getApplicationFontData();
+        for (var key in resources) {
+          appMeta.addResource(key, resources[key]);
+        }
+        let fontFaces = font.getFontFaces() || [];
+
+        // Break out the CSS into local resource files and URLs
+        let fontCss = font.getCss() || [];
+        let cssUrls = [];
+        let cssResources = [];
+        for (let urlOrPath of fontCss) {
+          if (urlOrPath.match(/^https?:/)) {
+            cssUrls.push(urlOrPath);
+          } else {
+            cssResources.push(urlOrPath);
+          }
+        }
+
+        // Exclude font files that we do not want to include
+        let types = this.getFontTypes();
+        let hasLocalFontResources = false;
+        let hasUrlFontResources = false;
+        if (types.length) {
+          for (let fontFace of fontFaces) {
+            fontFace.paths = fontFace.paths.filter(filename => {
+              let pos = filename.lastIndexOf(".");
+              if (pos > -1) {
+                let ext = filename.substring(pos + 1);
+                if (types.indexOf(ext) > -1) {
+                  return true;
+                }
+              }
+              if (!filename.match(/^https?:/)) {
+                hasLocalFontResources = true;
+              } else {
+                hasUrlFontResources = true;
+              }
+              return false;
+            });
+          }
+        }
+
+        // It is important to always prefer local fonts if we have them and are not instructed to prefer CDNs
+        let useLocalFonts = cssUrls.length == 0 && !hasUrlFontResources;
+        if (
+          this.isPreferLocalFonts() &&
+          (cssResources.length > 0 || hasLocalFontResources)
+        ) {
+          useLocalFonts = true;
+        }
+
+        // Make sure we add any CSS and font resource files to the target output
+        if (useLocalFonts) {
+          addResourcesToBuild(cssResources);
+
+          for (let fontFace of fontFaces) {
+            addResourcesToBuild(fontFace.paths);
+          }
+        }
+
+        var code = font.getBootstrapCode(this, application, useLocalFonts);
+
+        if (code) {
+          appMeta.addPreBootCode(code);
+        }
       }
-      await qx.Promise.all(promises);
-      await t._writeApplication();
-      this.__appMeta = null;
     },
 
     /**

package/source/class/qx/tool/migration/M7_5_6.js

@@ -0,0 +1,75 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023 Zenesis Limited https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (@johnspackman)
+
+************************************************************************ */
+
+const process = require("process");
+const path = require("upath");
+const semver = require("semver");
+const fs = qx.tool.utils.Promisify.fs;
+
+/**
+ * Migration class for updating to v7.5.6
+ */
+qx.Class.define("qx.tool.migration.M7_5_6", {
+  extend: qx.tool.migration.BaseMigration,
+  members: {
+    async migrateManifest() {
+      let dryRun = this.getRunner().getDryRun();
+      let verbose = this.getRunner().getVerbose();
+      // Update all Manifests
+      let updateManifest = false;
+      for (const manifestModel of await qx.tool.config.Utils.getManifestModels()) {
+        manifestModel.set({ warnOnly: true });
+        await manifestModel.load();
+        let data = manifestModel.getData();
+
+        if (
+          data.provides?.webfonts !== undefined &&
+          data.provides?.fonts === undefined
+        ) {
+          if (dryRun) {
+            this.markAsPending(
+              "provides.webfonts will be replaced with provides.fonts"
+            );
+          } else {
+            this.markAsApplied();
+            let fontsData = {};
+            data.provides.webfonts.forEach(data => {
+              let fontData = (fontsData[data.name] = {});
+              ["defaultSize", "comparisonString"].forEach(name => {
+                let value = data[name];
+                if (value !== undefined) {
+                  fontData[name] = value;
+                }
+              });
+              if (data.resources !== undefined) {
+                fontData.sources = data.resources;
+              }
+            });
+            data.provides.fonts = fontsData;
+            delete data.provides.webfonts;
+          }
+        }
+
+        // save Manifest file
+        if (!dryRun) {
+          await manifestModel.save();
+        }
+      }
+    }
+  }
+});

package/source/class/qx/tool/utils/Http.js

@@ -0,0 +1,69 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023 Zenesis Limited https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (@johnspackman)
+
+************************************************************************ */
+
+const fs = require("fs");
+const path = require("path");
+const tmp = require("tmp");
+const http = require("http");
+
+/**
+ * Helper methods for HTTP
+ */
+qx.Class.define("qx.tool.utils.Http", {
+  extend: qx.core.Object,
+
+  statics: {
+    /**
+     * Downloads a URL into a temporary file
+     *
+     * @param {String} url URL to download
+     * @param {RegEx?} contentTypeRegEx optional regex for the content type
+     * @return {String} temporary filename
+     */
+    async downloadToTempfile(url, contentTypeRegEx) {
+      let tmpFilename = await qx.tool.utils.Promisify.call(cb =>
+        tmp.tmpName(cb)
+      );
+
+      await new Promise((resolve, reject) => {
+        http.get(url, res => {
+          let error;
+          const { statusCode } = res;
+          const contentType = res.headers["content-type"];
+
+          if (statusCode !== 200) {
+            error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
+          } else if (contentTypeRegEx && !contentTypeRegEx.test(contentType)) {
+            error = new Error(`Invalid content-type, received ${contentType}`);
+          }
+
+          if (error) {
+            res.resume();
+            reject(error);
+            return;
+          }
+
+          let outFile = fs.createWriteStream(tmpFilename);
+          outFile.on("close", () => resolve(tmpFilename));
+          res.on("data", chunk => outFile.write(chunk));
+          res.on("end", () => outFile.end());
+        });
+      });
+    }
+  }
+});

package/source/class/qx/ui/basic/Image.js

@@ -634,7 +634,8 @@ qx.Class.define("qx.ui.basic.Image", {
           }
 
           // Don't transfer background image when switching from image to icon font
-          if (this.__getMode() === "font") {
+          var mode = this.__getMode();
+          if (mode === "font" || mode === "scaled") {
             delete styles.backgroundImage;
           }
 
@@ -785,7 +786,10 @@ qx.Class.define("qx.ui.basic.Image", {
       if (this.getScale()) {
         el.setStyle("fontSize", (width > height ? height : width) + "px");
       } else {
-        var source = qx.util.AliasManager.getInstance().resolve(this.getSource());
+        var source = qx.util.AliasManager.getInstance().resolve(
+          this.getSource()
+        );
+
         var sparts = source.split("/");
         var font = this.__getFont(source);
         var size = parseInt(sparts[2] || font.getSize());

package/source/class/qx/ui/basic/Label.js

@@ -318,15 +318,23 @@ qx.Class.define("qx.ui.basic.Label", {
       // Apply
       var styles;
       if (value) {
-        this.__font = qx.theme.manager.Font.getInstance().resolve(value);
-        if (this.__font instanceof qx.bom.webfonts.WebFont) {
-          if (!this.__font.isValid()) {
-            this.__webfontListenerId = this.__font.addListener(
-              "changeStatus",
-              this._onWebFontStatusChange,
-              this
-            );
-          }
+        if (qx.lang.Type.isString(value)) {
+          value = qx.theme.manager.Font.getInstance().resolve(value);
+        }
+        this.__font = value;
+        if (
+          this.__font instanceof qx.bom.webfonts.WebFont &&
+          !this.__font.isValid()
+        ) {
+          this.__webfontListenerId = this.__font.addListener(
+            "changeStatus",
+            evt => {
+              if (evt.getData().valid) {
+                this.__invalidContentSize = true;
+                qx.ui.core.queue.Layout.add(this);
+              }
+            }
+          );
         }
         styles = this.__font.getStyles();
       } else {
@@ -462,10 +470,10 @@ qx.Class.define("qx.ui.basic.Label", {
 
     // property apply
     _applyBreakWithinWords(value, old) {
-        this.getContentElement().setStyle(
-          "wordBreak",
+      this.getContentElement().setStyle(
+        "wordBreak",
         this.isRich() && value ? "break-all" : "normal"
-        );
+      );
     },
 
     /**
@@ -485,32 +493,6 @@ qx.Class.define("qx.ui.basic.Label", {
       false: null
     }),
 
-    /**
-     * Triggers layout recalculation after a web font was loaded
-     *
-     * @param ev {qx.event.type.Data} "changeStatus" event
-     */
-    _onWebFontStatusChange(ev) {
-      if (ev.getData().valid === true) {
-        // safari has trouble resizing, adding it again fixed the issue [BUG #8786]
-        if (
-          qx.core.Environment.get("browser.name") == "safari" &&
-          parseFloat(qx.core.Environment.get("browser.version")) >= 8
-        ) {
-          window.setTimeout(
-            function () {
-              this.__invalidContentSize = true;
-              qx.ui.core.queue.Layout.add(this);
-            }.bind(this),
-            0
-          );
-        }
-
-        this.__invalidContentSize = true;
-        qx.ui.core.queue.Layout.add(this);
-      }
-    },
-
     // property apply
     _applyValue: qx.core.Environment.select("qx.dynlocale", {
       true(value, old) {