Fix pat-upload lazification for imperative callers

The split left pat-structure, pat-relateditems and the contentbrowser app
importing the thin upload.js registration module and doing `new Upload()`.
That module grafts the implementation asynchronously in init(), so the
instance was missing its body (setPath, currentPath, the Dropzone wiring)
right after construction, breaking those callers.

Make upload--implementation.js a constructable Base.extend pattern again
and point the imperative callers at it, so `new Upload()` yields a fully
formed instance synchronously. The thin upload.js keeps registering the
.pat-upload trigger and grafts the implementation prototype on first match,
so the body still stays out of the eager patterns chunk (the implementation
is only reached via lazy chunks: the structure app view, the contentbrowser
component and the relateditems dynamic import). Registry.register is
first-wins, so the eagerly imported thin module remains the registered
.pat-upload pattern.

Add a regression test asserting the implementation is constructable and
exposes its methods synchronously.

Author: MrTango

src/pat/contentbrowser/src/ContentBrowser.svelte

@@ -5,7 +5,7 @@
     import { fly } from "svelte/transition";
     import _t from "../../../core/i18n-wrapper";
     import { ensureIntlSupport } from "../../../core/intl-loader";
-    import Upload from "../../upload/upload";
+    import Upload from "../../upload/upload--implementation";
     import contentStore from "./ContentStore";
     import {
         clickOutside,

src/pat/relateditems/relateditems.js

@@ -402,7 +402,7 @@ export default Base.extend({
     },
 
     async initUploadView(disabled) {
-        let Upload = await import("../upload/upload");
+        let Upload = await import("../upload/upload--implementation");
         Upload = Upload.default;
 
         const upload_button = this.$toolbar[0].querySelector(".upload button");

src/pat/structure/js/views/upload.js

@@ -1,7 +1,7 @@
 import $ from "jquery";
 import _ from "underscore";
 import PopoverView from "../../../../core/ui/views/popover";
-import Upload from "../../../upload/upload";
+import Upload from "../../../upload/upload--implementation";
 
 export default PopoverView.extend({
     className: "popover upload",

src/pat/upload/upload--implementation.js

@@ -1,16 +1,24 @@
 import $ from "jquery";
 import _ from "underscore";
 import _t from "../../core/i18n-wrapper";
+import Base from "@patternslib/patternslib/src/core/base";
 import logger from "@patternslib/patternslib/src/core/logging";
 import utils from "../../core/utils";
 
 const log = logger.getLogger("pat-upload");
 
 let Dropzone;
 
-// Pattern config object — grafted onto the thin registered pattern in
-// upload.js and run there. Kept out of the eager patterns chunk.
-export default {
+// The full pat-upload implementation. It stays out of the eager patterns chunk:
+// the thin upload.js registration module loads it on first `.pat-upload` match
+// and grafts its prototype. Imperative callers (pat-structure, pat-relateditems,
+// the contentbrowser app) import this module directly and `new Upload(...)` it,
+// so it must be a constructable Base.extend pattern, not a plain object grafted
+// asynchronously.
+export default Base.extend({
+    name: "upload",
+    trigger: ".pat-upload",
+    parser: "mockup",
     defaults: {
         showTitle: true,
         url: null, // XXX MUST provide url to submit to OR be in a form
@@ -497,4 +505,4 @@ export default {
         });
         return ri;
     },
-};
+});

src/pat/upload/upload--implementation.test.js

@@ -0,0 +1,23 @@
+import $ from "jquery";
+import Upload from "./upload--implementation";
+
+// pat-structure, pat-relateditems and the contentbrowser app construct upload
+// imperatively (`new Upload(el, options)`) and use the instance right away.
+// The implementation must therefore be a constructable pattern that exposes its
+// methods synchronously — not a config object grafted asynchronously by the thin
+// upload.js registration module.
+describe("upload implementation", function () {
+    let $el;
+    beforeEach(function () {
+        $el = $('<div class="pat-upload"/>').appendTo("body");
+    });
+    afterEach(function () {
+        $el.remove();
+    });
+
+    it("is constructable and exposes its methods synchronously", function () {
+        const upload = new Upload($el, { url: "/upload", currentPath: "/a" });
+        expect(typeof upload.setPath).toBe("function");
+        expect(typeof upload.getUrl).toBe("function");
+    });
+});

src/pat/upload/upload.js

@@ -10,14 +10,16 @@ export default Base.extend({
     parser: "mockup",
 
     init: async function () {
-        const impl = (await import("./upload--implementation")).default;
+        // The implementation is a full Base.extend pattern (imperative callers
+        // do `new Upload(...)`), so its instance behaviour lives on the
+        // prototype.
+        const proto = (await import("./upload--implementation")).default.prototype;
         // Defaults live with the implementation; merge them under the parsed
         // options (which must win), reproducing the eager pattern's options.
-        this.options = $.extend(true, {}, impl.defaults, this.options);
-        // Graft onto this single instance so consumers that instantiate Upload
-        // directly (pat-structure, pat-relateditems, the contentbrowser app)
-        // keep working against one object.
-        $.extend(this, impl);
-        return impl.init.apply(this, arguments);
+        this.options = $.extend(true, {}, proto.defaults, this.options);
+        // Graft onto this single instance so the pattern registers and behaves
+        // exactly as before, just with the heavy body loaded on demand.
+        $.extend(this, proto);
+        return proto.init.apply(this, arguments);
     },
 });