avo-rhino_field 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7aec35556234089518c72a1314cecb1836e3f47fcfc6cb89fc849175be65561
-  data.tar.gz: 3822aa64d2f78d877541a014cb28523b78eae4e464d001ae56793cf00b20c50d
+  metadata.gz: f53dc33bee0399e4168856086147e924ec745e4fd5e19f64d224d5a08013aa27
+  data.tar.gz: d3bcfef47a5e00b16688a1269f5eef46b493b06abc1ea64ca4c4f9c7f20fbad2
 SHA512:
-  metadata.gz: 3eda4c22cc990b70437fa1c9a402114728df1911c98eb02cc4c896c45c15c4e2a1d7c4af415356f02672aa2a3a2437799e486b42c2b3f8e236e9c2edcac81286
-  data.tar.gz: afff2c7d30daf2f51fcb4e18025edc4f684ec9f5dad3158a85765b6bd3c4e1bf7f4e53f1a0ead5d20d778ffe2290ab9ba5590e9cc4d9b72c534e7489b9574372
+  metadata.gz: 610cc47bd746312b5008fb09f1c779a57e8bd714f229ff67461e92b6db5f8e786fe113adcd5701aebbc541c802db2a8a1a1463b384866eca28da5b1b0c96901b
+  data.tar.gz: c00b3070dfe6479b3bc56ac1f1c97358bb39bd93ac4308c1f22a54dfb9bc696d9a9c8bcc04f5b1d1a6e6ceffd04648600e19e4ab079fa29b12577e96ea1bb80c

data/app/assets/builds/avo-rhino_field.js

@@ -29286,6 +29286,287 @@ img.ProseMirror-separator {
     }
   };
 
+  // node_modules/@rails/request.js/src/fetch_response.js
+  var FetchResponse = class {
+    constructor(response) {
+      this.response = response;
+    }
+    get statusCode() {
+      return this.response.status;
+    }
+    get redirected() {
+      return this.response.redirected;
+    }
+    get ok() {
+      return this.response.ok;
+    }
+    get unauthenticated() {
+      return this.statusCode === 401;
+    }
+    get unprocessableEntity() {
+      return this.statusCode === 422;
+    }
+    get authenticationURL() {
+      return this.response.headers.get("WWW-Authenticate");
+    }
+    get contentType() {
+      const contentType = this.response.headers.get("Content-Type") || "";
+      return contentType.replace(/;.*$/, "");
+    }
+    get headers() {
+      return this.response.headers;
+    }
+    get html() {
+      if (this.contentType.match(/^(application|text)\/(html|xhtml\+xml)$/)) {
+        return this.text;
+      }
+      return Promise.reject(new Error(`Expected an HTML response but got "${this.contentType}" instead`));
+    }
+    get json() {
+      if (this.contentType.match(/^application\/.*json$/)) {
+        return this.responseJson || (this.responseJson = this.response.json());
+      }
+      return Promise.reject(new Error(`Expected a JSON response but got "${this.contentType}" instead`));
+    }
+    get text() {
+      return this.responseText || (this.responseText = this.response.text());
+    }
+    get isTurboStream() {
+      return this.contentType.match(/^text\/vnd\.turbo-stream\.html/);
+    }
+    get isScript() {
+      return this.contentType.match(/\b(?:java|ecma)script\b/);
+    }
+    async renderTurboStream() {
+      if (this.isTurboStream) {
+        if (window.Turbo) {
+          await window.Turbo.renderStreamMessage(await this.text);
+        } else {
+          console.warn("You must set `window.Turbo = Turbo` to automatically process Turbo Stream events with request.js");
+        }
+      } else {
+        return Promise.reject(new Error(`Expected a Turbo Stream response but got "${this.contentType}" instead`));
+      }
+    }
+    async activeScript() {
+      if (this.isScript) {
+        const script = document.createElement("script");
+        const metaTag = document.querySelector("meta[name=csp-nonce]");
+        const nonce = metaTag && metaTag.content;
+        if (nonce) {
+          script.setAttribute("nonce", nonce);
+        }
+        script.innerHTML = await this.text;
+        document.body.appendChild(script);
+      } else {
+        return Promise.reject(new Error(`Expected a Script response but got "${this.contentType}" instead`));
+      }
+    }
+  };
+
+  // node_modules/@rails/request.js/src/request_interceptor.js
+  var RequestInterceptor = class {
+    static register(interceptor) {
+      this.interceptor = interceptor;
+    }
+    static get() {
+      return this.interceptor;
+    }
+    static reset() {
+      this.interceptor = void 0;
+    }
+  };
+
+  // node_modules/@rails/request.js/src/lib/utils.js
+  function getCookie(name) {
+    const cookies = document.cookie ? document.cookie.split("; ") : [];
+    const prefix = `${encodeURIComponent(name)}=`;
+    const cookie = cookies.find((cookie2) => cookie2.startsWith(prefix));
+    if (cookie) {
+      const value = cookie.split("=").slice(1).join("=");
+      if (value) {
+        return decodeURIComponent(value);
+      }
+    }
+  }
+  function compact(object) {
+    const result = {};
+    for (const key in object) {
+      const value = object[key];
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  function metaContent(name) {
+    const element = document.head.querySelector(`meta[name="${name}"]`);
+    return element && element.content;
+  }
+  function stringEntriesFromFormData(formData) {
+    return [...formData].reduce((entries, [name, value]) => {
+      return entries.concat(typeof value === "string" ? [[name, value]] : []);
+    }, []);
+  }
+  function mergeEntries(searchParams, entries) {
+    for (const [name, value] of entries) {
+      if (value instanceof window.File) continue;
+      if (searchParams.has(name) && !name.includes("[]")) {
+        searchParams.delete(name);
+        searchParams.set(name, value);
+      } else {
+        searchParams.append(name, value);
+      }
+    }
+  }
+
+  // node_modules/@rails/request.js/src/fetch_request.js
+  var FetchRequest = class {
+    constructor(method, url, options = {}) {
+      this.method = method;
+      this.options = options;
+      this.originalUrl = url.toString();
+    }
+    async perform() {
+      try {
+        const requestInterceptor = RequestInterceptor.get();
+        if (requestInterceptor) {
+          await requestInterceptor(this);
+        }
+      } catch (error) {
+        console.error(error);
+      }
+      const fetch = this.responseKind === "turbo-stream" && window.Turbo ? window.Turbo.fetch : window.fetch;
+      const response = new FetchResponse(await fetch(this.url, this.fetchOptions));
+      if (response.unauthenticated && response.authenticationURL) {
+        return Promise.reject(window.location.href = response.authenticationURL);
+      }
+      if (response.isScript) {
+        await response.activeScript();
+      }
+      const responseStatusIsTurboStreamable = response.ok || response.unprocessableEntity;
+      if (responseStatusIsTurboStreamable && response.isTurboStream) {
+        await response.renderTurboStream();
+      }
+      return response;
+    }
+    addHeader(key, value) {
+      const headers = this.additionalHeaders;
+      headers[key] = value;
+      this.options.headers = headers;
+    }
+    sameHostname() {
+      if (!this.originalUrl.startsWith("http:")) {
+        return true;
+      }
+      try {
+        return new URL(this.originalUrl).hostname === window.location.hostname;
+      } catch (_2) {
+        return true;
+      }
+    }
+    get fetchOptions() {
+      return {
+        method: this.method.toUpperCase(),
+        headers: this.headers,
+        body: this.formattedBody,
+        signal: this.signal,
+        credentials: this.credentials,
+        redirect: this.redirect
+      };
+    }
+    get headers() {
+      const baseHeaders = {
+        "X-Requested-With": "XMLHttpRequest",
+        "Content-Type": this.contentType,
+        Accept: this.accept
+      };
+      if (this.sameHostname()) {
+        baseHeaders["X-CSRF-Token"] = this.csrfToken;
+      }
+      return compact(
+        Object.assign(baseHeaders, this.additionalHeaders)
+      );
+    }
+    get csrfToken() {
+      return getCookie(metaContent("csrf-param")) || metaContent("csrf-token");
+    }
+    get contentType() {
+      if (this.options.contentType) {
+        return this.options.contentType;
+      } else if (this.body == null || this.body instanceof window.FormData) {
+        return void 0;
+      } else if (this.body instanceof window.File) {
+        return this.body.type;
+      }
+      return "application/json";
+    }
+    get accept() {
+      switch (this.responseKind) {
+        case "html":
+          return "text/html, application/xhtml+xml";
+        case "turbo-stream":
+          return "text/vnd.turbo-stream.html, text/html, application/xhtml+xml";
+        case "json":
+          return "application/json, application/vnd.api+json";
+        case "script":
+          return "text/javascript, application/javascript";
+        default:
+          return "*/*";
+      }
+    }
+    get body() {
+      return this.options.body;
+    }
+    get query() {
+      const originalQuery = (this.originalUrl.split("?")[1] || "").split("#")[0];
+      const params = new URLSearchParams(originalQuery);
+      let requestQuery = this.options.query;
+      if (requestQuery instanceof window.FormData) {
+        requestQuery = stringEntriesFromFormData(requestQuery);
+      } else if (requestQuery instanceof window.URLSearchParams) {
+        requestQuery = requestQuery.entries();
+      } else {
+        requestQuery = Object.entries(requestQuery || {});
+      }
+      mergeEntries(params, requestQuery);
+      const query = params.toString();
+      return query.length > 0 ? `?${query}` : "";
+    }
+    get url() {
+      return this.originalUrl.split("?")[0].split("#")[0] + this.query;
+    }
+    get responseKind() {
+      return this.options.responseKind || "html";
+    }
+    get signal() {
+      return this.options.signal;
+    }
+    get redirect() {
+      return this.options.redirect || "follow";
+    }
+    get credentials() {
+      return this.options.credentials || "same-origin";
+    }
+    get additionalHeaders() {
+      return this.options.headers || {};
+    }
+    get formattedBody() {
+      const bodyIsAString = Object.prototype.toString.call(this.body) === "[object String]";
+      const contentTypeIsJson = this.headers["Content-Type"] === "application/json";
+      if (contentTypeIsJson && !bodyIsAString) {
+        return JSON.stringify(this.body);
+      }
+      return this.body;
+    }
+  };
+
+  // node_modules/@rails/request.js/src/verbs.js
+  async function post(url, options) {
+    const request = new FetchRequest("post", url, options);
+    return request.perform();
+  }
+
   // app/javascript/controllers/rhino_field_controller.js
   function rgbStyleToHex2(color) {
     if (!color || color.indexOf("rgb") < 0) {
@@ -29302,6 +29583,10 @@ img.ProseMirror-separator {
   }
   var rhino_field_controller_default = class extends Controller {
     static targets = ["textColorInput", "backgroundColorInput"];
+    static values = {
+      resourceName: String,
+      resourceId: String
+    };
     get editor() {
       return this.element.editor;
     }
@@ -29358,6 +29643,33 @@ img.ProseMirror-separator {
         this.textColorInputTarget.value = this.DEFAULT_TEXT_COLOR;
       }
     }
+    async openGallery() {
+      post(`${window.Avo.configuration.root_path}/media_library`, {
+        query: {
+          resource_name: this.resourceNameValue,
+          record_id: this.resourceIdValue,
+          controller_selector: this.element.dataset.rhinoFieldUniqueSelectorValue,
+          controller_name: this.identifier
+        },
+        responseKind: "turbo-stream"
+      });
+    }
+    // Invoked by the other controllers (media-library)
+    insertAttachments(attachments, event) {
+      console.log("insertAttachment<>", this, event);
+      const editorAttachments = attachments.map((attachment) => {
+        const { blob, path } = attachment;
+        return new AttachmentManager({
+          src: path,
+          width: blob.width,
+          height: blob.height,
+          filename: blob.filename,
+          contentType: blob.content_type,
+          previewable: true
+        });
+      });
+      this.editor?.chain().focus().setAttachment(editorAttachments).run();
+    }
     setBackgroundColor(event) {
       const color = event.target.value;
       if (color) {